from datetime import datetime
from http.client import HTTPException
import os
from typing import Tuple
from fastapi import Path
from openai import OpenAI
import json
import pandas as pd
import requests
from pandasql import sqldf
import re
from loguru import logger

from app.datatk.data_help import DataHelp
from app.models.db import AnalysisReport


class AiPromptTask:
    def __init__():
        pass


    @staticmethod
    def build_task_breakdown_prompt(user_input: str, available_datasets: str = "", conversation_context: dict = None) -> str:
        """构建任务拆解提示词，将用户需求拆解为多个具体任务步骤
        
        参数:
            user_input (str): 用户输入的需求文本
            available_datasets (str, optional): 可用数据集信息，JSON格式字符串，默认为空
            conversation_context (dict, optional): 会话上下文信息，包含：
                - conversation_history: 历史对话记录
                - user_preferences: 用户偏好设置
                - previous_tasks: 之前执行的任务
                - session_context: 会话级别的上下文信息
                - domain_knowledge: 领域知识和业务背景
            
        返回:
            str: 用于任务拆解的提示词
        """
        
        # 智能分析用户需求中的关键词
        user_input_lower = user_input.lower()
        
        # 报告相关关键词
        report_keywords = [
            '报告', '报表', '总结', '汇总', '分析报告', '数据报告', '生成报告',
            '整理成报告', '形成报告', '输出报告', '制作报告',
            'report', 'summary', 'analysis report'
        ]
        
        # 检查用户是否明确要求报告
        needs_report = any(keyword in user_input_lower for keyword in report_keywords)
        
        # 构建任务类型指导
        task_type_guidance = ""
        if needs_report:
            task_type_guidance = """
        ## 🎯 任务类型识别指导
        
        **用户需求分析**：用户明确提到了报告需求
        
        **允许的任务类型**：
        1. ✅ **数据查询**：获取和分析数据，AI会自动生成相关图表
        2. ✅ **报告生成**：用户明确要求生成报告
        3. ✅ **未知任务**：无法归类的其他需求
        
        **智能图表说明**：系统会根据数据内容自动在回复中生成合适的ECharts图表，无需单独拆解图表任务。
        """
        else:
            task_type_guidance = """
        ## 🎯 任务类型识别指导
        
        **用户需求分析**：用户主要需要数据查询和分析
        
        **允许的任务类型**：
        1. ✅ **数据查询**：获取和分析数据，AI会自动生成相关图表
        2. ❌ **报告生成**：用户未明确要求，不要主动生成
        3. ✅ **未知任务**：无法归类的其他需求
        
        **重要说明**：
        - **图表自动生成**：当数据适合可视化时，AI会在回复中自动生成ECharts图表
        - **无需拆解图表任务**：不要单独创建图表制作任务，图表会作为数据查询结果的一部分展示
        - **专注核心需求**：专注于用户明确表达的数据查询和分析需求
        """
        
        # 处理上下文信息
        context = conversation_context or {}
        conversation_history = context.get('conversation_history', [])
        user_preferences = context.get('user_preferences', {})
        previous_tasks = context.get('previous_tasks', [])
        session_context = context.get('session_context', {})
        domain_knowledge = context.get('domain_knowledge', {})
        
        # 分析会话历史，提取关键信息
        context_analysis = ""
        if conversation_history:
            recent_topics = []
            mentioned_datasets = []
            analysis_patterns = []
            
            # 分析最近的对话
            for msg in conversation_history[-5:]:  # 只分析最近5条消息
                if isinstance(msg, dict):
                    content = msg.get('content', '')
                    # 提取数据集提及
                    if '数据' in content or '表' in content:
                        mentioned_datasets.append(content)
                    # 提取分析模式
                    if any(keyword in content for keyword in ['分析', '统计', '图表', '报告']):
                        analysis_patterns.append(content)
                    # 提取主题
                    recent_topics.append(content[:50])  # 截取前50字符作为主题
            
            context_analysis = f"""
        ## 📋 会话上下文分析
        
        ### 最近对话主题
        {chr(10).join([f"- {topic}" for topic in recent_topics[-3:]]) if recent_topics else "- 无历史对话"}
        
        ### 提及的数据集
        {chr(10).join([f"- {dataset[:100]}" for dataset in mentioned_datasets[-3:]]) if mentioned_datasets else "- 无特定数据集提及"}
        
        ### 分析模式偏好
        {chr(10).join([f"- {pattern[:100]}" for pattern in analysis_patterns[-3:]]) if analysis_patterns else "- 无明显分析偏好"}
        """
        
        # 分析用户偏好
        preference_analysis = ""
        if user_preferences:
            detail_level = user_preferences.get('detail_level', 'balanced')  # simple/balanced/detailed
            chart_preference = user_preferences.get('chart_preference', [])
            report_style = user_preferences.get('report_style', 'standard')
            
            preference_analysis = f"""
        ## 🎯 用户偏好分析
        
        ### 详细程度偏好
        - **{detail_level}模式**: {"简洁快速" if detail_level == "simple" else "平衡适中" if detail_level == "balanced" else "详细深入"}
        
        ### 图表偏好
        {chr(10).join([f"- {chart}" for chart in chart_preference]) if chart_preference else "- 无特定图表偏好"}
        
        ### 报告风格
        - **{report_style}**: {"标准商务报告" if report_style == "standard" else "简洁摘要" if report_style == "summary" else "详细分析报告"}
        """
        
        # 分析之前的任务
        task_history_analysis = ""
        if previous_tasks:
            task_types = [task.get('任务类型', '') for task in previous_tasks[-5:]]
            successful_patterns = []
            
            for task in previous_tasks[-3:]:
                if task.get('status') == 'completed':
                    successful_patterns.append(f"{task.get('任务类型', '')}: {task.get('任务标题', '')}")
            
            task_history_analysis = f"""
        ## 📊 任务历史分析
        
        ### 最近任务类型
        {chr(10).join([f"- {task_type}" for task_type in task_types if task_type]) if task_types else "- 无历史任务"}
        
        ### 成功执行的任务模式
        {chr(10).join([f"- {pattern}" for pattern in successful_patterns]) if successful_patterns else "- 无成功任务记录"}
        """
        
        # 构建智能化的上下文感知提示词
        return f"""
        # 🧠 智能任务规划专家 - 精准需求识别系统

        ## 角色设定
        你是一位精通数据分析全流程的高级规划专家，具备强大的需求识别和上下文感知能力。你能够：
        - 精准理解用户的真实需求，避免过度拆解
        - 基于用户明确表达的需求进行任务规划
        - 只在用户明确要求时才生成图表和报告任务
        - 专注于用户核心数据需求，提供精准的任务拆解

        {context_analysis}
        {preference_analysis}
        {task_history_analysis}
        {task_type_guidance}

        ## 📋 系统支持的任务类型

        ### 1. **数据查询**：获取数据或进行数据分析
        - 包括简单数据获取、统计分析、比例分析、分布分析、趋势分析等
        - 通过SQL查询直接获得所需的数据结果
        - **智能图表展示**：系统会根据数据内容和用户问题自动生成合适的ECharts图表展示
        - 根据"分析类型"属性区分：
          * "数据获取"：只需要结构化数据，不需要AI分析解读
          * "数据分析"：需要基于数据进行AI深度分析和解读

        ### 2. **报告生成**：制作专业报告
        - ⚠️ **重要**：只有当用户明确提到报告、总结、汇总等关键词时才生成此类任务
        - 包括文本内容、图表展示、分析结论等
        - 基于数据查询任务的结果生成综合性报告
        - 报告中会自动包含相关的图表和可视化展示
        - 根据用户的报告风格偏好调整结构和内容

        ### 3. **未知任务**：不属于上述两种任务的其他需求
        - 提供可行的替代方案，引导用户转向系统支持的任务类型

        ## 🔍 精准需求识别原则

        ### 核心原则：按需拆解，避免过度
        1. **明确性原则**：只有用户明确表达的需求才进行拆解
        2. **最小化原则**：优先满足用户核心需求，避免不必要的任务
        3. **精准性原则**：准确理解用户意图，不要主观添加任务
        4. **实用性原则**：专注于用户真正需要的功能

        ### 任务拆解判断标准

        #### 🔍 数据查询任务（总是需要）
        - 用户提到：查询、获取、分析、统计、计算、比较等数据操作
        - 这是最基础的任务类型，几乎所有需求都需要
        - **图表自动生成**：当数据适合可视化时，AI会在回复中自动生成ECharts图表
        - **智能图表选择**：基于数据类型和用户问题自动选择最合适的图表类型

        #### 📄 报告生成任务（仅在明确要求时）
        **生成条件**：用户明确提到以下关键词
        - 报告词汇：报告、报表、总结、汇总、分析报告、数据报告
        - 生成词汇：生成报告、整理成报告、形成报告、输出报告
        - 英文词汇：report、summary、analysis report

        **不生成条件**：
        - 用户只是要数据分析
        - 用户没有明确提到报告需求
        - 用户只是想了解分析结果

        ## 🔍 当前用户需求分析

        ### 用户输入
        **用户需求**："{user_input}"

        ### 需求关键词识别
        - **图表相关关键词检测**：{"✅ 检测到" if needs_chart else "❌ 未检测到"}
        - **报告相关关键词检测**：{"✅ 检测到" if needs_report else "❌ 未检测到"}

        ### 任务拆解策略
        基于关键词检测结果：
        - **数据查询任务**：✅ 必须生成（满足核心数据需求）
        - **图表制作任务**：{"✅ 可以生成" if needs_chart else "❌ 不要生成（用户未明确要求）"}
        - **报告生成任务**：{"✅ 可以生成" if needs_report else "❌ 不要生成（用户未明确要求）"}

        ## 📊 可用数据集信息
        ```
        {available_datasets}
        ```

        ## 🎯 任务拆解执行指令

        ### 核心要求
        1. **严格按需拆解**：只生成用户明确需要的任务类型
        2. **避免过度拆解**：不要主观添加用户未要求的任务
        3. **专注核心需求**：优先满足用户的数据分析需求
        4. **精准理解意图**：准确识别用户真正想要什么

        ### 特别注意事项
        - 如果用户没有明确提到图表，绝对不要生成图表制作任务
        - 如果用户没有明确提到报告，绝对不要生成报告生成任务
        - 专注于数据查询和分析，这是用户的核心需求
        - 宁可任务少而精准，也不要多而冗余

        ## 📋 输出格式要求

        你必须输出一个严格的JSON数组格式，每个子任务信息作为数组中的一个对象，必须包含以下字段：

        - **任务组号**：标识任务所属的任务组
        - **任务类型**：必须是四种任务类型之一
        - **任务标题**：简洁描述任务目标
        - **任务要求**：详细的任务执行信息

        ### 针对不同任务类型的"任务要求"字段内容：

        #### 1. **数据查询任务**：
        ```json
        {{
          "说明": "对查询需求的简要描述",
          "分析类型": "数据获取或数据分析，用于区分是否需要AI解读",
          "数据集": "目标数据集名称",
          "字段": "所需字段列表，逗号分隔，可包含聚合函数",
          "限制条件": "筛选条件描述,分组统计要求,排序要求,时间范围,数据量限制,去重要求等",
          "数据说明": "数据内容的简要描述,不超过20字"
        }}
        ```

        #### 2. **图表制作任务**（仅在用户明确要求时生成）：
        ```json
        {{
          "说明": "图表制作的目标描述",
          "图表任务源": "依赖的数据查询任务标题，多个用逗号分隔",
          "图表类型": "所需图表类型，如饼图、柱状图等",
          "维度字段": "用于分类或X轴的字段（可选）",
          "度量字段": "用于计算或Y轴的字段（可选）",
          "颜色设置": "颜色方案要求（可选）"
        }}
        ```

        #### 3. **报告生成任务**（仅在用户明确要求时生成）：
        ```json
        {{
          "说明": "报告生成的目标描述",
          "报告任务源": "依赖的数据查询或图表任务标题，多个用逗号分隔",
          "报告类型": "报告的类型，如摘要报告、详细报告等",
          "内容要求": "报告内容的具体要求",
          "格式要求": "报告格式的特殊要求（可选）"
        }}
        ```

        #### 4. **未知任务**：
        ```json
        {{
          "说明": "对未知任务的描述",
          "建议任务类型": "推荐用户采用的任务类型",
          "原因": "任务无法直接执行的原因"
        }}
        ```

        ## ⚡ 执行指令

        现在，请基于上述精准需求识别分析和用户当前需求，生成智能化的任务拆解方案。

        **特别强调**：
        1. 严格遵循需求识别结果，不要生成用户未明确要求的任务类型
        2. 专注于用户的核心数据需求，避免过度拆解
        3. 如果用户没有明确要求图表，绝对不要生成图表制作任务
        4. 如果用户没有明确要求报告，绝对不要生成报告生成任务
        5. 确保输出的JSON格式严格有效，无语法错误

        **开始精准任务拆解** ⬇️
        """

    @staticmethod
    def build_task_sql_prompt(task_info: dict, dataset_schema: dict) -> str:
        """构建SQL生成提示词，为获取数据任务生成执行SQL
        
        参数:
            task_info (dict): 获取数据任务的详细信息
            dataset_schema (dict): 数据集的结构信息，包含表名、字段名等
            
        返回:
            str: 用于SQL生成的提示词
        """
        
        # 获取数据库类型
        # 首先尝试从dataset_schema中直接获取数据库类型
        db_type = dataset_schema.get("数据库类型", "").lower()
        # 如果数据库类型为空，设置为默认值
        if not db_type:
            db_type = "mysql"  # 默认使用MySQL
      
        tablename = dataset_schema.get("表名", "")
        
        # 直接获取格式化的SQL生成规则字符串
        sql_rules = AiPromptTask.get_sql_generation_rules(db_type, format_type="formatted")
        
        # 构建完整提示词
        return f"""
        # 角色设定
        你是一位精通SQL语法和数据库查询的专家，擅长将自然语言描述的数据需求转化为精确的SQL查询语句。你的任务是根据提供的数据获取任务要求和数据集结构信息，生成精确、高效的SQL语句。

        # 任务详情
        你需要为以下"获取数据"任务生成SQL语句:
        ```json
        {json.dumps(task_info, ensure_ascii=False, indent=2)}
        ```

        # 数据集结构信息
        ```json
        {json.dumps(dataset_schema, ensure_ascii=False, indent=2)}
        ```

        # 数据库语法规则
        {sql_rules}

        # SQL生成规则
        1. 字段选择：
           - 只选择任务要求中指定的字段
           - 字段名和表名不要使用双引号包围，直接使用原始名称
           - 如果字段名包含空格或特殊字符，使用反引号(`)或方括号([])包围，避免使用双引号
           - 如果需要计算字段，确保提供有意义的别名

        2. 标识符引用规则：
           - MySQL: 使用反引号包围特殊字段名，如 `字段名`
           - SQL Server: 使用方括号包围特殊字段名，如 [字段名]
           - SQLite: 直接使用字段名，避免引号，如 字段名
           - PostgreSQL: 使用双引号时要谨慎，优先直接使用字段名
           - Oracle: 使用双引号时要谨慎，优先直接使用字段名
           - 通用规则: 优先直接使用字段名，避免任何引号包围

        3. 表关联：
           - 当需要多表查询时，识别合适的关联字段
           - 使用适当的JOIN类型（INNER JOIN、LEFT JOIN等）
           - 确保关联条件明确且正确

        4. 筛选条件：
           - 正确转化任务中描述的所有限制条件为WHERE子句
           - 处理各种条件表达式（等于、大于、LIKE、IN等）
           - 处理日期、文本和数值类型的条件比较

        5. 聚合与排序：
           - 如有聚合要求，使用GROUP BY和聚合函数
           - 按要求添加ORDER BY子句
           - 添加LIMIT子句限制返回结果数量（如有要求）

        6. SQL优化：
           - 确保SQL语句语法正确，可直接执行
           - 避免不必要的子查询或复杂结构
           - 避免SELECT *，除非特别要求
           - 使用表别名提高可读性
           - 字段名和表名直接使用，不要添加双引号包围

        7. GROUP BY特别规则 (适用于ONLY_FULL_GROUP_BY模式)：
           - 必须确保SELECT语句中的每个非聚合列都出现在GROUP BY子句中
           - 错误示例: SELECT a, b, SUM(c) FROM table GROUP BY a
           - 正确示例: SELECT a, b, SUM(c) FROM table GROUP BY a, b
           - 复杂表达式处理: 如果SELECT中使用了表达式(如CASE语句或函数调用)，在GROUP BY中必须使用完全相同的表达式
           - 例如: SELECT YEAR(date_col), SUM(sales) FROM table GROUP BY YEAR(date_col)
           - 非分组字段处理方法:
             * MySQL: SELECT group_col, ANY_VALUE(non_group_col), SUM(value) FROM table GROUP BY group_col
             * 其他数据库: SELECT group_col, MAX(non_group_col), SUM(value) FROM table GROUP BY group_col
             * 或者将额外字段加入GROUP BY: SELECT group_col, extra_col, SUM(value) FROM table GROUP BY group_col, extra_col

        8. 子查询别名规则（重要）：
           - 所有子查询（包括派生表）必须有别名
           - 错误示例: SELECT * FROM (SELECT col1, col2 FROM table1) WHERE col1 > 0
           - 正确示例: SELECT * FROM (SELECT col1, col2 FROM table1) AS subquery WHERE col1 > 0
           - UNION查询的子查询也需要别名: SELECT * FROM (SELECT a FROM t1 UNION SELECT b FROM t2) AS union_result
           - CTE（公用表表达式）可以替代复杂子查询，但仍需要别名
           - 嵌套子查询中的每一层都必须有别名

        # 错误处理策略
        如果无法生成有效的SQL，必须明确指出原因，可能包括：
        - 任务要求中的字段在数据集结构中不存在
        - 数据集结构信息不完整或有冲突
        - 任务描述中的限制条件无法准确转化为SQL条件

        # 输出格式
        返回一个JSON对象，包含以下字段：
        - status："success"或"failed"
        - sql：生成的SQL语句（如果失败则为空字符串）
        - 说明：成功时简要说明SQL实现了什么功能，失败时说明原因(不超过20字)

        # 生成SQL时需要注意：
        1. 确保所有字段名和表名的引用与数据集结构中的完全一致
        2. 根据数据集结构正确处理数据类型（如日期格式化、字符串比较等）
        3. 避免SQL注入风险，正确处理字符串值的引号
        4. 限制条件中可能包含排序要求,时间范围,数据量限制,去重要求等,确保生成的SQL完全符合{db_type}数据库的标准语法
        5. 确保生成的SQL完全符合{db_type}数据库的标准语法
        6. 表名使用{tablename}（如非空）
        7. 字段名和表名不要使用双引号包围，直接使用原始名称，避免SQL执行错误
        8. 如果字段名包含特殊字符，根据数据库类型使用正确的标识符引用方式：
           - MySQL: 使用反引号 `字段名`
           - SQL Server: 使用方括号 [字段名]  
           - SQLite: 直接使用字段名，避免引号
           - 其他数据库: 优先直接使用字段名
        9. 对于使用GROUP BY的查询，确保严格遵循GROUP BY规则，特别是：
           - 所有非聚合字段必须出现在GROUP BY子句中
           - 表达式必须完全一致地出现在SELECT和GROUP BY中
           - 对于不需要参与分组但想显示的字段，使用适当的聚合函数

        # 现在，请基于上述任务要求和数据集结构，生成一个有效的SQL查询语句：
        """
   
    @staticmethod
    def get_sql_generation_rules(db_type: str = "mysql", format_type: str = "dict") -> dict | str:
        """获取指定数据库类型的SQL生成规则和相关知识
        
        参数:
            db_type (str): 数据库类型 (mysql, sqlite, sqlserver, postgresql, oracle, 默认mysql)
            format_type (str): 返回格式类型 ("dict": 结构化字典, "formatted": 格式化字符串)
            
        返回:
            dict | str: 根据format_type返回结构化字典或格式化字符串
        """
        
        # 统一转换为小写处理
        db_type = db_type.lower()
        
        # 构建特定数据库类型的SQL语法规则
        sql_syntax_rules = ""
        identifier_rules = ""
        
        if db_type == "sqlite":
            sql_syntax_rules = """
SQLite SQL语法规则:
1. 标识符引用
   - 字段名和表名直接使用，不要使用双引号包围
   - 如果字段名包含空格或特殊字符，可以使用方括号 [字段名] 或反引号 `字段名`
   - 避免使用双引号 "字段名"，这可能导致执行错误
   
2. 日期处理函数
   - 日期格式化: strftime('%Y-%m-%d', date_column)
   - 按年分组: strftime('%Y', date_column)
   - 按月分组: strftime('%Y-%m', date_column)
   - 按日分组: strftime('%Y-%m-%d', date_column)
   - 当前日期: date('now')
   - 相对日期: date('now', '-1 month')

3. 字符串处理
   - 字符串连接: column1 || ' ' || column2
   - 子字符串: substr(column, start, length)
   - 大小写: upper(column), lower(column)

4. 条件表达式
   - CASE WHEN condition THEN result ELSE result END

5. 分页
   - LIMIT number OFFSET number
   
6. 字符串与数值转换
   - 字符串转数值: CAST(string_value AS INTEGER/REAL)
   - 数值转字符串: CAST(numeric_value AS TEXT)
   
7. 聚合函数
   - SUM(), AVG(), MIN(), MAX(), COUNT()
   - GROUP_CONCAT(column, separator)
   
8. GROUP BY规则
   - SELECT语句中的非聚合列必须出现在GROUP BY子句中
   - 例如：SELECT a, b, SUM(c) FROM table GROUP BY a, b
   - 或使用聚合函数：SELECT a, MAX(b), SUM(c) FROM table GROUP BY a
"""
            identifier_rules = "SQLite: 直接使用字段名，特殊字符时使用方括号 [字段名] 或反引号 `字段名`"
            
        elif db_type == "mysql":
            sql_syntax_rules = """
MySQL SQL语法规则:
1. 标识符引用
   - 字段名和表名直接使用，不要使用双引号包围
   - 如果字段名包含空格或特殊字符，使用反引号 `字段名`
   - 避免使用双引号 "字段名"，这可能导致执行错误
   
2. 日期处理函数
   - 日期格式化: DATE_FORMAT(date_column, '%Y-%m-%d')
   - 年份提取: YEAR(date_column)
   - 月份提取: MONTH(date_column)
   - 按年月分组: DATE_FORMAT(date_column, '%Y-%m')
   - 当前日期: CURDATE()
   - 相对日期: DATE_SUB(CURDATE(), INTERVAL 1 MONTH)

3. 字符串处理
   - 字符串连接: CONCAT(column1, ' ', column2)
   - 子字符串: SUBSTRING(column, start, length)
   - 大小写: UPPER(column), LOWER(column)

4. 条件表达式
   - CASE WHEN condition THEN result ELSE result END
   - IF(condition, true_result, false_result)

5. 分页
   - LIMIT offset, count
   - LIMIT count OFFSET offset
   
6. 字符串与数值转换
   - 字符串转数值: CAST(string_value AS SIGNED/DECIMAL)
   - 数值转字符串: CAST(numeric_value AS CHAR)
   
7. 聚合函数
   - SUM(), AVG(), MIN(), MAX(), COUNT()
   - GROUP_CONCAT(column SEPARATOR ',')
   
8. GROUP BY规则 (ONLY_FULL_GROUP_BY模式下)
   - SELECT语句中的非聚合列必须出现在GROUP BY子句中
   - 错误示例: SELECT a, b, SUM(c) FROM table GROUP BY a
   - 正确示例: SELECT a, b, SUM(c) FROM table GROUP BY a, b
   - 如果不需要按b分组，则应使用聚合函数: SELECT a, MAX(b), SUM(c) FROM table GROUP BY a
   - 使用ANY_VALUE()函数可包含非分组字段: SELECT a, ANY_VALUE(b), SUM(c) FROM table GROUP BY a
   
9. 子查询别名规则（重要）：
   - 所有子查询（包括派生表）必须有别名
   - 错误示例: SELECT * FROM (SELECT col1, col2 FROM table1) WHERE col1 > 0
   - 正确示例: SELECT * FROM (SELECT col1, col2 FROM table1) AS subquery WHERE col1 > 0
   - UNION查询也需要别名: SELECT * FROM (SELECT a FROM t1 UNION SELECT b FROM t2) AS union_result
   - 每个子查询都必须有唯一的别名
"""
            identifier_rules = "MySQL: 使用反引号包围特殊字段名，如 `字段名`"
            
        elif db_type in ["sqlserver", "mssql"]:
            sql_syntax_rules = """
SQL Server语法规则:
1. 标识符引用
   - 字段名和表名直接使用，不要使用双引号包围
   - 如果字段名包含空格或特殊字符，使用方括号 [字段名]
   - 避免使用双引号 "字段名"，这可能导致执行错误
   
2. 日期处理函数
   - 日期格式化: CONVERT(VARCHAR, date_column, 120) 或 CONVERT(VARCHAR, date_column, 23)
   - 年份提取: DATEPART(YEAR, date_column) 或 YEAR(date_column)
   - 月份提取: DATEPART(MONTH, date_column) 或 MONTH(date_column)
   - 日提取: DATEPART(DAY, date_column) 或 DAY(date_column)
   - 小时提取: DATEPART(HOUR, date_column)
   - 分钟提取: DATEPART(MINUTE, date_column) 
   - 秒提取: DATEPART(SECOND, date_column)
   - 按年月分组: CONVERT(VARCHAR(7), date_column, 120)
   - 当前日期: GETDATE()
   - 相对日期: DATEADD(month, -1, GETDATE())
   - 日期部分: DATEPART(year/month/day, date_column)

3. 字符串处理
   - 字符串连接: column1 + ' ' + column2
   - 子字符串: SUBSTRING(column, start, length)
   - 大小写: UPPER(column), LOWER(column)

4. 聚合函数: SUM(), AVG(), MIN(), MAX(), COUNT()
   - 字符串聚合: 使用FOR XML PATH('')实现字符串拼接
   
5. 统计分析函数:
   - 排名: ROW_NUMBER() OVER(PARTITION BY column ORDER BY column)
   - 前N名: TOP n
   - 百分位: PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY column) OVER (PARTITION BY group_column)

6. 分页:
   - SQL Server 2005+(使用ROW_NUMBER): 
     WITH CTE AS (
         SELECT ROW_NUMBER() OVER (ORDER BY order_column) AS RowNum, 
                columns
         FROM table
         WHERE conditions
     )
     SELECT columns FROM CTE 
     WHERE RowNum BETWEEN start_row AND end_row
   - 简单取前N条: TOP n 
   
7. 条件判断:
   - CASE WHEN condition THEN result ELSE result END
   - ISNULL(column, default_value)
   
8. GROUP BY规则:
   - SELECT语句中的非聚合列必须出现在GROUP BY子句中
   - SELECT中的每个输出列必须是聚合函数结果，或者出现在GROUP BY子句中
   - 如果SELECT中包含复杂表达式，该表达式也必须完整地出现在GROUP BY中
   - 例如: SELECT CONVERT(VARCHAR(7), date_column, 120) AS month, SUM(sales)
     FROM table GROUP BY CONVERT(VARCHAR(7), date_column, 120)
   - CASE表达式必须完整地出现在GROUP BY中
"""
            identifier_rules = "SQL Server: 使用方括号包围特殊字段名，如 [字段名]"
            
        elif db_type in ["postgresql", "postgres"]:
            sql_syntax_rules = """
PostgreSQL语法规则:
1. 标识符引用
   - 字段名和表名直接使用，不要使用双引号包围
   - 如果字段名包含空格或特殊字符，可以使用双引号，但要谨慎使用
   - 优先直接使用字段名，避免引号包围
   
2. 日期处理函数
   - 日期格式化: TO_CHAR(date_column, 'YYYY-MM-DD')
   - 年份提取: EXTRACT(YEAR FROM date_column)
   - 月份提取: EXTRACT(MONTH FROM date_column)
   - 按年月分组: TO_CHAR(date_column, 'YYYY-MM')
   - 当前日期: CURRENT_DATE
   - 相对日期: CURRENT_DATE - INTERVAL '1 month'

3. 字符串处理
   - 字符串连接: column1 || ' ' || column2
   - 子字符串: SUBSTRING(column FROM start FOR length)
   - 大小写: UPPER(column), LOWER(column)

4. 聚合函数: SUM(), AVG(), MIN(), MAX(), COUNT()
   - STRING_AGG(column, ',')

5. 分页: LIMIT count OFFSET offset

6. GROUP BY规则:
   - SELECT语句中的非聚合列必须出现在GROUP BY子句中
   - PostgreSQL强制执行"only_full_group_by"规则
   - 如果SELECT中包含复杂表达式，该表达式也必须完整地出现在GROUP BY中
   - 例如: SELECT TO_CHAR(date_column, 'YYYY-MM') AS month, SUM(sales)
     FROM table GROUP BY TO_CHAR(date_column, 'YYYY-MM')
   - 可以使用聚合函数例如 MAX(), MIN()等包含不需要分组的字段
"""
            identifier_rules = "PostgreSQL: 使用双引号时要谨慎，优先直接使用字段名"
            
        elif db_type == "oracle":
            sql_syntax_rules = """
Oracle SQL语法规则:
1. 标识符引用
   - 字段名和表名直接使用，不要使用双引号包围
   - 如果字段名包含空格或特殊字符，可以使用双引号，但要谨慎使用
   - 优先直接使用字段名，避免引号包围
   
2. 日期处理函数
   - 日期格式化: TO_CHAR(date_column, 'YYYY-MM-DD')
   - 年份提取: EXTRACT(YEAR FROM date_column)
   - 月份提取: EXTRACT(MONTH FROM date_column)
   - 按年月分组: TO_CHAR(date_column, 'YYYY-MM')
   - 当前日期: SYSDATE, CURRENT_DATE
   - 相对日期: ADD_MONTHS(SYSDATE, -1)

3. 字符串处理
   - 字符串连接: column1 || ' ' || column2
   - 子字符串: SUBSTR(column, start, length)
   - 大小写: UPPER(column), LOWER(column)

4. 聚合函数: SUM(), AVG(), MIN(), MAX(), COUNT()
   - LISTAGG(column, ',') WITHIN GROUP (ORDER BY column)

5. 分页:
   - 使用ROWNUM: SELECT * FROM (YOUR_QUERY) WHERE ROWNUM <= n
   - 12c及以上版本: OFFSET offset ROWS FETCH NEXT count ROWS ONLY
   
6. GROUP BY规则:
   - SELECT语句中的非聚合列必须出现在GROUP BY子句中
   - 如果SELECT中包含复杂表达式，该表达式也必须完整地出现在GROUP BY中
   - 例如: SELECT TO_CHAR(date_column, 'YYYY-MM') AS month, SUM(sales)
     FROM table GROUP BY TO_CHAR(date_column, 'YYYY-MM')
   - 对于CASE表达式，整个表达式必须出现在GROUP BY中
"""
            identifier_rules = "Oracle: 使用双引号时要谨慎，优先直接使用字段名"
            
        else:  # 通用SQL规则
            sql_syntax_rules = """
通用SQL语法规则:
1. 标识符引用
   - 字段名和表名直接使用，不要使用双引号包围
   - 优先直接使用字段名，避免任何引号包围
   - 如果必须使用引号，根据具体数据库选择合适的引用方式
   
2. 确保每个SQL语句语法完全正确，并可直接执行
3. 优先使用标准SQL语法，确保兼容性
4. 使用适当的注释提高可读性
5. 确保GROUP BY子句包含所有非聚合字段
   - 在SELECT列表中的所有非聚合列必须出现在GROUP BY子句中
   - 错误示例: SELECT column1, column2, SUM(column3) FROM table GROUP BY column1
   - 正确示例: SELECT column1, column2, SUM(column3) FROM table GROUP BY column1, column2
   - 如果不需要按某列分组，应使用聚合函数: SELECT column1, MAX(column2), SUM(column3) FROM table GROUP BY column1
6. 输出格式依据需求使用别名和正确的显示名称
7. 避免除零错误
8. 根据用户需求添加适当的ORDER BY和LIMIT子句
9. 使用简单子查询实现复杂操作
10. 条件表达式使用标准CASE WHEN语法
11. 子查询别名规则（重要）：
    - 所有子查询（包括派生表）必须有别名
    - 错误示例: SELECT * FROM (SELECT col1, col2 FROM table1) WHERE col1 > 0
    - 正确示例: SELECT * FROM (SELECT col1, col2 FROM table1) AS subquery WHERE col1 > 0
    - UNION查询也需要别名: SELECT * FROM (SELECT a FROM t1 UNION SELECT b FROM t2) AS union_result
    - 每个子查询都必须有唯一的别名
"""
            identifier_rules = "通用规则: 优先直接使用字段名，避免任何引号包围"
        
        # 构建完整的SQL生成知识字典
        sql_knowledge = {
            "database_type": db_type,
            "sql_syntax_rules": sql_syntax_rules.strip(),
            "identifier_rules": identifier_rules,
            "core_generation_rules": {
                "field_selection": "只选择任务要求中指定的字段，避免SELECT *",
                "identifier_quoting": "字段名和表名不要使用双引号包围，直接使用原始名称",
                "table_joins": "当需要多表查询时，识别合适的关联字段，使用适当的JOIN类型",
                "filter_conditions": "正确转化任务中描述的所有限制条件为WHERE子句",
                "aggregation_sorting": "如有聚合要求，使用GROUP BY和聚合函数，按要求添加ORDER BY子句",
                "sql_optimization": "确保SQL语句语法正确，可直接执行，使用表别名提高可读性"
            },
            "group_by_rules": {
                "basic_rule": "SELECT语句中的每个非聚合列都必须出现在GROUP BY子句中",
                "complex_expressions": "如果SELECT中使用了表达式，在GROUP BY中必须使用完全相同的表达式",
                "non_group_fields": "对于不需要参与分组但想显示的字段，使用适当的聚合函数",
                "mysql_specific": "MySQL可使用ANY_VALUE()函数包含非分组字段",
                "examples": {
                    "wrong": "SELECT a, b, SUM(c) FROM table GROUP BY a",
                    "correct": "SELECT a, b, SUM(c) FROM table GROUP BY a, b"
                }
            },
            "subquery_alias_rules": {
                "requirement": "所有子查询（包括派生表）必须有别名",
                "examples": {
                    "wrong": "SELECT * FROM (SELECT col1, col2 FROM table1) WHERE col1 > 0",
                    "correct": "SELECT * FROM (SELECT col1, col2 FROM table1) AS subquery WHERE col1 > 0"
                },
                "union_queries": "UNION查询也需要别名",
                "nested_queries": "嵌套子查询中的每一层都必须有别名"
            },
            "common_pitfalls": [
                "避免在字段名和表名上使用双引号包围",
                "GROUP BY子句必须包含所有非聚合字段",
                "子查询必须有别名",
                "注意数据库特定的日期和字符串处理函数",
                "避免SQL注入风险，正确处理字符串值",
                "根据数据库类型使用正确的标识符引用方式"
            ],
            "best_practices": [
                "使用具有描述性的字段别名",
                "优化查询性能，合理使用索引字段",
                "根据需求添加适当的LIMIT限制",
                "使用标准SQL语法确保兼容性",
                "复杂查询分解为简单子查询",
                "添加必要的注释提高可读性"
            ]
        }
        
        # 根据format_type返回不同格式
        if format_type == "formatted":
            # 返回格式化的字符串，可直接用于提示词
            formatted_rules = f"""
## 🔧 SQL语句智能生成指南

当意图类型为 `data_query` 时，必须在 `generated_sql` 字段中生成可执行的SQL语句。

### 🎯 数据库类型：{db_type.upper()}

### 📋 核心生成规则
{chr(10).join([f"- **{key.replace('_', ' ').title()}**: {value}" for key, value in sql_knowledge['core_generation_rules'].items()])}

### 🔧 标识符引用规则
{identifier_rules}

### 📜 数据库特定语法规则
{sql_syntax_rules.strip()}

### ⚠️ GROUP BY 专项规则（关键）
- **基本规则**: {sql_knowledge['group_by_rules']['basic_rule']}
- **复杂表达式**: {sql_knowledge['group_by_rules']['complex_expressions']}
- **非分组字段**: {sql_knowledge['group_by_rules']['non_group_fields']}
- **MySQL特定**: {sql_knowledge['group_by_rules']['mysql_specific']}

**GROUP BY 示例**:
- ❌ 错误: `{sql_knowledge['group_by_rules']['examples']['wrong']}`
- ✅ 正确: `{sql_knowledge['group_by_rules']['examples']['correct']}`

### 🏗️ 子查询别名规则（重要）
- **要求**: {sql_knowledge['subquery_alias_rules']['requirement']}
- **UNION查询**: {sql_knowledge['subquery_alias_rules']['union_queries']}
- **嵌套查询**: {sql_knowledge['subquery_alias_rules']['nested_queries']}

**子查询示例**:
- ❌ 错误: `{sql_knowledge['subquery_alias_rules']['examples']['wrong']}`
- ✅ 正确: `{sql_knowledge['subquery_alias_rules']['examples']['correct']}`

### 🚨 常见陷阱提醒
{chr(10).join([f"- {pitfall}" for pitfall in sql_knowledge['common_pitfalls']])}

### 💡 最佳实践建议
{chr(10).join([f"- {practice}" for practice in sql_knowledge['best_practices']])}

### 📝 SQL生成示例

**基础查询示例**：
```sql
-- 查询各专业学生数量
SELECT major, COUNT(*) as student_count 
FROM students 
GROUP BY major 
ORDER BY student_count DESC 
LIMIT 10;

-- 按条件筛选
SELECT name, age, major 
FROM students 
WHERE age >= 18 AND major LIKE '%计算机%' 
ORDER BY age DESC;
```

**复杂统计示例**：
```sql
-- 多维度分析（确保GROUP BY包含所有非聚合字段）
SELECT 
    major, 
    gender, 
    COUNT(*) as student_count,
    AVG(age) as avg_age
FROM students 
WHERE age >= 18 
GROUP BY major, gender 
ORDER BY student_count DESC;
```

**子查询示例**：
```sql
-- 子查询必须有别名
SELECT s.major, s.avg_score 
FROM (
    SELECT major, AVG(score) as avg_score 
    FROM students 
    GROUP BY major
) AS s 
WHERE s.avg_score > 80;
```

### ✅ SQL质量检查清单
生成SQL前，请确认：
1. ✅ 字段名和表名没有使用双引号包围
2. ✅ GROUP BY包含了所有非聚合字段
3. ✅ 子查询都有别名
4. ✅ 使用了数据库特定的正确语法
5. ✅ WHERE条件合理且安全
6. ✅ 使用了适当的ORDER BY和LIMIT
7. ✅ SQL语句可以直接执行

**重要提醒**：
- 生成的SQL必须语法正确且可直接执行
- 严格遵循{db_type.upper()}数据库的语法规则
- 优先考虑查询性能和安全性
- 根据用户具体需求精准生成，避免过度复杂化
"""
            return formatted_rules.strip()
        else:
            # 默认返回结构化字典
            return sql_knowledge

    @staticmethod
    def build_data_analysis_prompt(
        task_name: str, 
        task_requirements: dict, 
        data: list
    ) -> str:
        """
        构建数据分析提示词
        支持大数据量智能处理，避免token超限问题
        
        参数:
            task_name (str): 任务名称
            task_requirements (dict): 任务要求
            data (list): 查询得到的数据
            
        返回:
            str: 数据分析提示词
        """
        
        # 导入数据处理器
        from app.ai.data_processor import DataProcessor
        
        # 使用数据处理器智能处理数据
        processed_result = DataProcessor.process_task_data(
            task_data=data if isinstance(data, list) else [data] if data else [],
            task_description=f"{task_name} - {task_requirements.get('说明', '')}"
        )
        
        # 获取处理后的数据和元信息
        processed_data = processed_result.get("processed_data", [])
        data_summary = processed_result.get("data_summary", "")
        processing_strategy = processed_result.get("processing_strategy", "none")
        original_count = processed_result.get("original_count", 0)
        processed_count = processed_result.get("processed_count", 0)
        
        # 构建智能数据描述
        data_description = ""
        analysis_guidance = ""
        
        if processing_strategy == "direct":
            data_description = f"""**数据概况**: {data_summary}
**完整数据**: {processed_data}"""
            analysis_guidance = """
### 📋 小数据量分析策略
- 可以对每条数据进行详细分析
- 提供精确的数值和具体的对比
- 适合做逐项分析和细致的模式识别
"""
        elif processing_strategy == "sample":
            data_overview = processed_result.get("data_overview", {})
            data_description = f"""**数据概况**: {data_summary}
**数据总览**: {data_overview}
**代表性样本**: {processed_data}
**重要说明**: 以下分析基于{original_count}条原始数据的{processed_count}条代表性样本"""
            analysis_guidance = f"""
### 🎯 采样数据分析策略
- 基于{original_count}条数据的代表性样本分析
- 重点关注数据模式、趋势和分布特征
- 在分析中明确说明"基于代表性样本"
- 避免过度精确的数值声明，使用趋势性描述
"""
        elif processing_strategy == "aggregate":
            statistical_summary = processed_result.get("statistical_summary", {})
            data_description = f"""**数据概况**: {data_summary}
**统计摘要**: {statistical_summary}
**聚合数据**: {processed_data}
**重要说明**: 以下分析基于{original_count}条原始数据的聚合统计"""
            analysis_guidance = f"""
### 📊 聚合数据分析策略
- 基于{original_count}条数据的汇总统计分析
- 重点使用统计指标、平均值、总计等汇总信息
- 在分析中明确说明"基于汇总统计"
- 专注宏观趋势和整体特征，避免细节分析
"""
        elif processing_strategy == "summary":
            detailed_summary = processed_result.get("detailed_summary", {})
            key_insights = processed_result.get("key_insights", [])
            data_description = f"""**数据概况**: {data_summary}
**详细统计**: {detailed_summary}
**关键洞察**: {key_insights}
**代表性样本**: {processed_data}
**重要说明**: 以下分析基于{original_count}条原始数据的统计摘要"""
            analysis_guidance = f"""
### 🔍 大数据摘要分析策略
- 基于{original_count}条数据的统计摘要分析
- 重点关注关键洞察、整体趋势和宏观模式
- 在分析中明确说明"基于大数据统计分析"
- 使用统计指标和趋势描述，避免具体数值细节
"""
        else:
            data_description = "**数据状态**: 查询结果为空或无有效数据"
            analysis_guidance = """
### 🚫 空数据处理策略
- 明确说明数据为空的情况
- 分析可能的原因（查询条件、数据源等）
- 提供数据获取的建议和解决方案
"""
        
        return f"""
# 角色设定
你是一位资深的数据分析专家，擅长从数据中发现洞察和趋势，并提供专业的分析解读。
你具备处理不同规模数据的能力，能够根据数据量级调整分析策略和深度。

# 分析任务
**任务名称**: {task_name}
**任务说明**: {task_requirements.get('说明', '无说明')}
**数据集**: {task_requirements.get('数据集', '未知')}
**查询字段**: {task_requirements.get('字段', '未知')}
**限制条件**: {task_requirements.get('限制条件', '无限制')}
**数据处理策略**: {processing_strategy}
**原始数据量**: {original_count} 条
**分析数据量**: {processed_count} 条

# 智能处理后的数据
{data_description}

{analysis_guidance}

# 分析要求
请基于上述智能处理后的数据进行深度分析，包括但不限于：

## 1. **数据概览**
- 总体数据情况描述
- 数据质量和完整性评估
- 关键统计指标概述

## 2. **关键发现**
- 从数据中发现的重要信息和趋势
- 异常值或特殊模式的识别
- 数据分布特征和规律

## 3. **深度洞察**
- 数据背后的业务含义和可能原因
- 不同维度间的关联性分析
- 潜在的业务机会或风险点

## 4. **结论建议**
- 基于分析结果的结论和建议
- 可行的业务改进方案
- 后续数据收集或分析建议

# 输出格式
请以专业、清晰的方式组织分析报告，使用markdown格式，确保内容具有实用价值。

# 重要注意事项

## 数据处理透明度
- **必须在分析报告中明确说明数据处理方式**
- 如果使用了采样数据，请说明"本分析基于{original_count}条数据的代表性样本"
- 如果使用了聚合数据，请说明"本分析基于{original_count}条数据的汇总统计"
- 如果是大数据摘要，请说明"本分析基于{original_count}条数据的统计摘要"

## 分析精度调整
- **小数据量**：可以提供精确数值和详细分析
- **中等数据量**：重点关注模式和趋势，适度使用具体数值
- **大数据量**：使用统计指标和趋势描述，避免过度精确的细节
- **超大数据量**：专注宏观洞察和关键趋势，使用统计性描述

## 质量保证
- 分析要客观、准确，基于实际处理后的数据
- 避免过度解读或无根据的推测
- 如果数据量较少或经过处理，请如实说明分析的局限性
- 重点关注数据的业务价值和实际意义
- 确保分析结论与数据处理方式相匹配

## 业务价值导向
- 将数据发现转化为可执行的业务洞察
- 提供具体、可操作的改进建议
- 考虑分析结果的实际应用场景
- 平衡分析深度与数据可信度

**开始专业数据分析** ⬇️
"""
   
    @staticmethod
    def build_task_breakdown_prompt_strict(user_input: str, available_datasets: str = "", conversation_context: dict = None) -> str:
        """构建严格模式的任务拆解提示词（快速模式）
        
        严格模式特点：
        - 只有用户明确要求时才生成图表和报告任务
        - 任务数量少，执行速度快
        - 专注于核心数据需求
        
        参数:
            user_input (str): 用户输入的需求文本
            available_datasets (str, optional): 可用数据集信息，JSON格式字符串，默认为空
            conversation_context (dict, optional): 会话上下文信息
            
        返回:
            str: 用于任务拆解的提示词
        """
        
        # 智能分析用户需求中的关键词
        user_input_lower = user_input.lower()
        
        # 报告相关关键词（更精准的检测）
        report_keywords = [
            '报告', '报表', '总结', '汇总', '分析报告', '数据报告', '生成报告', '写报告',
            '整理成报告', '形成报告', '输出报告', '制作报告', '报告文档', '分析总结',
            'report', 'summary', 'analysis report', 'generate report', 'create report'
        ]
        
        # 检查用户是否明确要求报告
        needs_report = any(keyword in user_input_lower for keyword in report_keywords)
        
        # 构建任务类型限制说明
        task_restrictions = ""
        if needs_report:
            task_restrictions = """
        ✅ **任务许可**：用户明确要求报告
        - 允许生成数据查询任务，AI会自动生成相关图表
        - 允许生成报告生成任务
        - 图表会在数据分析回复中自动生成，无需单独拆解
        """
        else:
            task_restrictions = """
        ⚠️ **重要限制**：用户未明确要求报告，只生成数据查询任务！
        - 禁止生成报告生成任务
        - 专注于数据获取和分析
        - 图表会在数据分析回复中自动生成，无需单独拆解图表任务
        """

        return f"""
# 🚀 极速任务规划器 - 严格模式

## 核心原则：最小化 + 精准化
- 只生成用户明确要求的任务
- 任务数量控制在1-3个以内
- 优先满足核心数据需求
- 绝不主观添加额外任务

## 用户需求分析
        **输入**："{user_input}"
        **报告需求**：{"✅ 明确要求" if needs_report else "❌ 未要求"}
        **图表说明**：系统会根据数据内容自动在回复中生成ECharts图表

{task_restrictions}

## 可用数据集
```json
{available_datasets}
```

## 任务类型定义

        ### 1. 数据查询（必须）
        - **成功任务**：获取数据、统计分析、计算指标
        - **失败任务**：当用户需求无法在现有数据集中实现时，生成失败任务说明原因
        - **图表自动生成**：AI会在回复中根据数据内容自动生成ECharts图表
        - 分析类型：数据获取/数据分析

        ### 2. 报告生成（条件生成）
        - 仅当检测到报告关键词时生成
        - 基于数据查询任务结果生成综合性报告
        - 报告中会自动包含相关图表和可视化内容

## 🚨 无法拆解情况处理

### 常见无法拆解的情况
1. **数据集不匹配**：用户要求的数据在现有数据集中不存在
2. **字段缺失**：用户提到的字段在数据集中找不到
3. **业务场景不符**：用户需求与数据集业务场景不匹配
4. **数据范围超出**：用户要求的数据范围超出现有数据集覆盖范围

### 失败任务处理策略
当遇到无法拆解的情况时：
1. **必须生成一个数据查询任务**（保证至少有一个任务）
2. **任务状态设为失败**：在任务要求中明确标记为失败
3. **详细说明失败原因**：在说明字段中清楚解释为什么无法执行
4. **提供改进建议**：如果可能，建议用户如何调整需求

## 输出要求
输出结构化JSON数组，每个任务包含完整信息：

⚠️ **重要**：输出前必须进行去重检查，确保没有相同字段组合的任务！

### 成功任务输出格式
```json
[{{
  "任务组号": 1,
  "任务类型": "数据查询",
  "任务标题": "简洁明确的标题",
  "任务要求": {{
    "说明": "简要描述",
    "分析类型": "数据获取或数据分析",
    "数据集": "数据集名称",
    "字段": "字段列表",
    "限制条件": "筛选条件",
    "数据说明": "数据用途",
    "执行状态": "pending"
  }}
}}]
```

### 失败任务输出格式
```json
[{{
  "任务组号": 1,
  "任务类型": "数据查询",
  "任务标题": "数据查询失败 - [失败原因简述]",
  "任务要求": {{
    "说明": "详细的失败原因说明",
    "分析类型": "数据获取",
    "数据集": "无匹配数据集",
    "字段": "无可用字段",
    "限制条件": "无法执行",
    "数据说明": "任务执行失败",
    "执行状态": "failed",
    "失败原因": "具体失败原因",
  }}
}}]
```

## 执行指令

### 核心执行流程
1. **需求可行性分析**：首先分析用户需求是否能在现有数据集中实现
2. **数据集匹配检查**：检查用户提到的数据、字段是否在可用数据集中存在
3. **任务生成策略**：
   - 如果需求可实现：生成正常的数据查询任务
   - 如果需求无法实现：生成失败的数据查询任务，详细说明原因
4. **严格按关键词检测结果生成图表和报告任务**
5. **任务去重检查**：
   - 检查字段组合是否重复
   - 检查查询条件是否相同
   - 合并相似任务
6. **控制任务数量，避免冗余**
7. **确保JSON格式正确**

### 需求可行性判断标准
- **数据集匹配度**：用户需求的数据类型是否与现有数据集匹配
- **字段可用性**：用户提到的字段是否在数据集中存在
- **业务场景符合度**：用户的分析需求是否符合数据集的业务场景
- **数据范围覆盖度**：用户要求的数据范围是否在数据集覆盖范围内

### 失败任务生成原则
1. **必须生成任务**：即使无法执行，也要生成一个数据查询任务
2. **明确失败状态**：在任务要求中设置"执行状态": "failed"
3. **详细失败原因**：清楚说明为什么无法执行
4. **建设性建议**：提供用户可以调整需求的具体建议
5. **避免误导**：不要给出可能误导用户的信息

### 任务去重要求
⚠️ **严格避免重复任务**：
1. **字段组合去重**：不能生成相同字段组合的任务
2. **SQL逻辑去重**：避免生成会产生相同SQL的任务
3. **分析目标去重**：相同分析目标只生成一个任务
4. **数据源去重**：同一数据集的相同查询只能有一个

### 去重检查标准
- **字段重复检查**：如果两个任务使用完全相同的字段列表，则为重复
- **条件重复检查**：如果两个任务的筛选条件和分组条件相同，则为重复
- **目标重复检查**：如果两个任务的分析目标和数据说明相同，则为重复
- **合并原则**：发现重复时，应合并为一个更全面的任务

### 去重检查示例
❌ **错误示例**（重复任务）：
```
任务1: 字段["姓名", "年龄", "性别"], 条件["年龄>18"]
任务2: 字段["姓名", "年龄", "性别"], 条件["年龄>18"] 
```

✅ **正确示例**（不重复任务）：
```
任务1: 字段["姓名", "年龄", "性别"], 条件["年龄>18"]
任务2: 字段["姓名", "年龄", "部门"], 条件["年龄>25"] 
任务3: 字段["部门", "COUNT(*)"], 条件["GROUP BY 部门"]
```

### 特别注意事项
- 失败任务的标题要明确标注"数据查询失败"
- 失败原因要具体，不要使用模糊的描述
- 改进建议要实用，帮助用户理解如何调整需求
- 后续程序会根据"执行状态"字段判断是否执行任务
- **必须确保每个任务的字段组合和查询逻辑都是唯一的**

**开始智能需求分析和极速拆解** ⬇️
"""

    @staticmethod
    def build_task_breakdown_prompt_complete(user_input: str, available_datasets: str = "", conversation_context: dict = None) -> str:
        """构建完整模式的任务拆解提示词（丰富模式）
        
        完整模式特点：
        - 智能推荐相关的图表和报告任务
        - 任务数量多，结果丰富完整
        - 提供全面的数据分析流程
        
        参数:
            user_input (str): 用户输入的需求文本
            available_datasets (str, optional): 可用数据集信息，JSON格式字符串，默认为空
            conversation_context (dict, optional): 会话上下文信息
            
        返回:
            str: 用于任务拆解的提示词
        """
        
        # 分析用户需求类型
        user_input_lower = user_input.lower()
        
        # 分析关键词，判断数据分析场景
        analysis_keywords = {
            '分布分析': ['分布', '分布情况', '分布状况', '分布特征', 'distribution'],
            '对比分析': ['对比', '比较', '差异', '差别', 'compare', 'comparison'],
            '趋势分析': ['趋势', '变化', '发展', '走势', 'trend', 'change'],
            '统计分析': ['统计', '汇总', '总计', '平均', 'statistics', 'summary'],
            '关联分析': ['关联', '关系', '相关', '影响', 'correlation', 'relationship'],
            '排名分析': ['排名', '排序', '前几', '最高', '最低', 'ranking', 'top']
        }
        
        # 检测分析场景
        detected_scenarios = []
        for scenario, keywords in analysis_keywords.items():
            if any(keyword in user_input_lower for keyword in keywords):
                detected_scenarios.append(scenario)
        
        # 如果没有检测到特定场景，默认为基础分析
        if not detected_scenarios:
            detected_scenarios = ['基础分析']
        
        # 处理上下文信息
        context = conversation_context or {}
        conversation_history = context.get('conversation_history', [])
        user_preferences = context.get('user_preferences', {})
        
        # 分析会话历史中的偏好
        historical_preferences = ""
        if conversation_history:
            chart_mentions = 0
            report_mentions = 0
            for msg in conversation_history[-5:]:
                if isinstance(msg, dict):
                    content = msg.get('content', '').lower()
                    if any(word in content for word in ['图表', '图', 'chart', '可视化']):
                        chart_mentions += 1
                    if any(word in content for word in ['报告', 'report', '总结']):
                        report_mentions += 1
            
            if chart_mentions > 0 or report_mentions > 0:
                historical_preferences = f"""
## 📊 历史偏好分析
- 图表偏好指数：{chart_mentions}/5 {"(偏好可视化)" if chart_mentions >= 2 else ""}
- 报告偏好指数：{report_mentions}/5 {"(偏好报告)" if report_mentions >= 2 else ""}
"""

        # 根据分析场景推荐图表类型
        chart_recommendations = {
            '分布分析': ['直方图', '箱线图', '饼图'],
            '对比分析': ['柱状图', '雷达图', '对比条形图'],
            '趋势分析': ['折线图', '面积图', '时间序列图'],
            '统计分析': ['表格', '仪表盘', '统计卡片'],
            '关联分析': ['散点图', '热力图', '相关性矩阵'],
            '排名分析': ['排名条形图', '排名表格', 'TOP图表'],
            '基础分析': ['柱状图', '饼图', '表格']
        }
        
        # 生成推荐的图表类型
        recommended_charts = []
        for scenario in detected_scenarios:
            recommended_charts.extend(chart_recommendations.get(scenario, []))
        recommended_charts = list(set(recommended_charts))  # 去重

        return f"""
# 🎨 智能分析规划师 - 完整模式

## 模式特色：全面 + 智能 + 个性化
- 基于场景智能推荐任务组合
- 提供端到端分析解决方案
- 考虑用户历史偏好和习惯
- 确保分析结果的完整性和专业性

## 需求智能解析
**用户输入**："{user_input}"
**检测场景**：{' + '.join(detected_scenarios)}
**推荐图表**：{', '.join(recommended_charts[:3])}

{historical_preferences}

## 可用数据集
```json
{available_datasets}
```

## 智能任务推荐策略

### 场景化任务组合
根据检测到的分析场景，智能推荐最佳任务组合：

**{detected_scenarios[0]}场景**：
- 🔍 **数据查询**：获取相关数据，进行{detected_scenarios[0]}
- 📊 **图表制作**：推荐{recommended_charts[0] if recommended_charts else '柱状图'}展示结果
- 📄 **分析报告**：生成{detected_scenarios[0]}专业报告

### 任务层次结构
1. **基础层**：数据获取和预处理
2. **分析层**：深度分析和计算
3. **展示层**：可视化图表制作
4. **总结层**：分析报告和洞察

## 🚨 无法拆解情况处理

### 常见无法拆解的情况
1. **数据集不匹配**：用户要求的数据在现有数据集中不存在
2. **字段缺失**：用户提到的字段在数据集中找不到
3. **业务场景不符**：用户需求与数据集业务场景不匹配
4. **数据范围超出**：用户要求的数据范围超出现有数据集覆盖范围

### 失败任务处理策略
当遇到无法拆解的情况时：
1. **必须生成一个数据查询任务**（保证至少有一个任务）
2. **任务状态设为失败**：在任务要求中明确标记为失败
3. **详细说明失败原因**：在说明字段中清楚解释为什么无法执行
4. **提供改进建议**：如果可能，建议用户如何调整需求

## 完整任务类型体系

### 1. 数据查询任务
- **成功任务**：获取数据、统计分析、深度挖掘
- **失败任务**：当用户需求无法在现有数据集中实现时，生成失败任务说明原因
- **基础查询**：获取原始数据
- **统计分析**：计算统计指标
- **深度挖掘**：多维度分析

### 2. 图表制作任务（智能推荐）
- **场景匹配**：根据分析场景推荐最佳图表
- **多样化展示**：提供2-3种不同视角的图表
- **交互增强**：考虑图表的交互性和美观度

### 3. 报告生成任务（智能推荐）
- **结构化报告**：包含背景、分析、结论
- **洞察提取**：深度挖掘数据背后的业务价值
- **建议输出**：提供可行的业务建议

### 4. 高级分析任务（可选）
- **预测分析**：基于历史数据进行预测
- **异常检测**：识别数据中的异常模式
- **关联挖掘**：发现变量间的隐藏关联

## 输出格式规范

输出结构化JSON数组，每个任务包含完整信息：

⚠️ **重要**：输出前必须进行去重检查，确保没有相同字段组合的任务！

### 成功任务输出格式
```json
[
  {{
    "任务组号": 1,
    "任务类型": "数据查询",
    "任务标题": "描述性标题",
    "任务要求": {{
      "说明": "详细的任务描述和目标",
      "分析类型": "数据获取/数据分析",
      "数据集": "目标数据集名称",
      "字段": "详细字段列表，支持聚合函数",
      "限制条件": "完整的筛选、分组、排序要求",
      "数据说明": "数据内容和分析目标说明",
      "执行状态": "pending"
    }}
  }},
  {{
    "任务组号": 2,
    "任务类型": "图表制作",
    "任务标题": "可视化展示标题",
    "任务要求": {{
      "说明": "图表制作的目标和价值",
      "图表任务源": "依赖的数据查询任务标题",
      "图表类型": "基于场景推荐的图表类型",
      "维度字段": "X轴或分类字段",
      "度量字段": "Y轴或数值字段",
      "颜色设置": "颜色方案建议",
      "推荐理由": "为什么推荐这种图表类型",
      "执行状态": "pending"
    }}
  }},
  {{
    "任务组号": 3,
    "任务类型": "报告生成",
    "任务标题": "分析报告标题",
    "任务要求": {{
      "说明": "报告生成的目标和价值",
      "报告任务源": "依赖的数据查询和图表任务",
      "报告类型": "基于场景的报告类型",
      "内容要求": "报告的具体内容结构",
      "格式要求": "报告的格式和样式要求",
      "推荐理由": "为什么需要这个报告",
      "执行状态": "pending"
    }}
  }}
]
```

### 失败任务输出格式
```json
[
  {{
    "任务组号": 1,
    "任务类型": "数据查询",
    "任务标题": "数据查询失败 - [失败原因简述]",
    "任务要求": {{
      "说明": "详细的失败原因说明，包括为什么无法在现有数据集中实现用户需求",
      "分析类型": "数据获取",
      "数据集": "无匹配数据集",
      "字段": "无可用字段",
      "限制条件": "无法执行",
      "数据说明": "任务执行失败，建议调整需求",
      "执行状态": "failed",
      "失败原因": "具体失败原因：数据集不匹配/字段缺失/业务场景不符/数据范围超出",
      "改进建议": "给用户的具体改进建议，如何调整需求才能执行"
    }}
  }}
]
```

## 智能执行指令

### 核心执行流程
1. **需求可行性分析**：首先分析用户需求是否能在现有数据集中实现
2. **数据集匹配检查**：检查用户提到的数据、字段是否在可用数据集中存在
3. **任务生成策略**：
   - 如果需求可实现：生成完整的任务组合（数据查询+图表+报告）
   - 如果需求无法实现：生成失败的数据查询任务，详细说明原因
4. **智能推荐**：基于场景和偏好推荐图表和报告任务
5. **任务去重检查**：
   - 检查字段组合是否重复
   - 检查查询条件是否相同
   - 合并相似任务，确保每个任务都有独特价值
6. **确保JSON格式正确**

### 需求可行性判断标准
- **数据集匹配度**：用户需求的数据类型是否与现有数据集匹配
- **字段可用性**：用户提到的字段是否在数据集中存在
- **业务场景符合度**：用户的分析需求是否符合数据集的业务场景
- **数据范围覆盖度**：用户要求的数据范围是否在数据集覆盖范围内

### 失败任务生成原则
1. **必须生成任务**：即使无法执行，也要生成一个数据查询任务
2. **明确失败状态**：在任务要求中设置"执行状态": "failed"
3. **详细失败原因**：清楚说明为什么无法执行
4. **建设性建议**：提供用户可以调整需求的具体建议
5. **避免误导**：不要给出可能误导用户的信息

### 成功任务生成策略
1. **场景适配**：根据检测的分析场景生成最佳任务组合
2. **层次清晰**：确保任务间的逻辑依赖关系明确
3. **价值导向**：每个任务都要有明确的分析价值
4. **完整性保证**：提供从数据到洞察的完整链路

### 推荐策略
- 基于分析场景智能推荐图表类型
- 考虑用户历史偏好调整任务权重
- 确保任务组合的协调性和完整性
- 为每个推荐任务提供充分的理由

### 质量标准
- 任务标题具有描述性和吸引力
- 任务要求详细且可执行
- 推荐理由充分且有说服力
- JSON格式严格正确

### 任务去重要求
⚠️ **严格避免重复任务**：
1. **字段组合去重**：不能生成相同字段组合的任务
2. **SQL逻辑去重**：避免生成会产生相同SQL的任务
3. **分析目标去重**：相同分析目标只生成一个任务
4. **数据源去重**：同一数据集的相同查询只能有一个

### 去重检查标准
- **字段重复检查**：如果两个任务使用完全相同的字段列表，则为重复
- **条件重复检查**：如果两个任务的筛选条件和分组条件相同，则为重复
- **目标重复检查**：如果两个任务的分析目标和数据说明相同，则为重复
- **合并原则**：发现重复时，应合并为一个更全面的任务

### 去重检查示例
❌ **错误示例**（重复任务）：
```
任务1: 字段["销售额", "产品名称"], 条件["销售额>1000"]
任务2: 字段["销售额", "产品名称"], 条件["销售额>1000"] 
```

✅ **正确示例**（不重复任务）：
```
任务1: 字段["销售额", "产品名称"], 条件["销售额>1000"] - 基础查询
任务2: 字段["产品名称", "SUM(销售额)"], 条件["GROUP BY 产品名称"] - 统计分析
任务3: 字段["销售日期", "销售额"], 条件["ORDER BY 销售日期"] - 趋势分析
```

### 完整模式去重策略
- **多维度分析**：同一数据集可以有多个不同维度的分析任务
- **层次化去重**：确保基础查询、统计分析、深度挖掘任务各不相同
- **场景化区分**：不同分析场景的任务要有明显的字段和条件差异
- **智能合并**：相似任务应合并为一个更全面的任务，而不是拆分为多个

### 特别注意事项
- 失败任务的标题要明确标注"数据查询失败"
- 失败原因要具体，不要使用模糊的描述
- 改进建议要实用，帮助用户理解如何调整需求
- 后续程序会根据"执行状态"字段判断是否执行任务
- 完整模式下也要确保任务的实际可执行性
- **必须确保每个任务的字段组合和查询逻辑都是唯一的**
- **完整模式虽然任务多，但每个任务都必须有独特的分析价值**

        **开始智能全面拆解** ⬇️
"""

    @staticmethod
    def build_intent_analysis_prompt(
        user_input: str, 
        context: dict, 
        available_tasks: list
    ) -> str:
        """构建高级意图识别与任务拆解提示词
        
        让AI自主分析和拆解用户需求，专为业务系统智能助手设计，支持：
        - 复杂需求智能拆解
        - 多意图并发识别
        - 复杂业务场景理解  
        - 上下文感知分析
        - 参数智能提取
        - 多轮对话支持
        - SQL语句智能生成
        - 任务依赖关系分析
        
        参数:
            user_input (str): 用户输入内容
            context (dict): 会话上下文信息
            available_tasks (list): 可用任务配置列表
            
        返回:
            str: 高级意图识别与任务拆解提示词
        """
        
        # 提取上下文信息
        conversation_history = context.get('messages', [])[-5:]  # 最近5条消息
        available_datasets = context.get('datasets', [])
        user_profile = context.get('user_profile', {})
        session_context = context.get('session_context', {})
        business_domain = context.get('business_domain', '通用业务系统')
        accessible_knowledge_bases = context.get('accessible_knowledge_bases', [])  # 用户有权限的知识库ID列表
        
        # 分析可用任务的类型分布
        api_tasks = [task for task in available_tasks if task.get('type') == 'api_function']
        data_query_tasks = [task for task in available_tasks if task.get('type') == 'data_query']
        
        # 构建数据集信息和SQL生成规则
        datasets_info = ""
        sql_generation_rules = ""
        
        if available_datasets:
            datasets_info = f"""

### 可用数据集
{chr(10).join([f"- {ds.get('name', '')}: {ds.get('dataset_summary', '')}" for ds in available_datasets]) if available_datasets else "- 无可用数据集"}

### 数据集使用说明
- 每个数据集包含数据集名称(name)、表名、字段列表、数据类型等信息
- data_query类型的意图需要指定dataset_id和生成SQL语句
- **重要**：dataset_id字段必须使用数据集的"name"字段（数据集名称），不是表名
- 在SQL语句中使用对应的表名进行查询
- 根据用户需求选择合适的数据集进行查询

### dataset_id使用规范
⚠️ **关键要求**：
- ✅ **正确做法**：dataset_id = 数据集的"name"字段（如："销售数据集"、"学生信息数据集"）
- ❌ **错误做法**：dataset_id = 表名（如："sales_table"、"students"）
- 💡 **记忆方法**：dataset_id是数据集标识，不是表标识
"""
            
            # 获取主要数据库类型（假设所有数据集使用相同类型）
            db_type = "mysql"  # 默认值
            if available_datasets:
                first_dataset = available_datasets[0]
                db_type = first_dataset.get("数据库类型", "mysql").lower()
            
            # 直接获取格式化的SQL生成规则字符串
            sql_generation_rules = AiPromptTask.get_sql_generation_rules(db_type, format_type="formatted")
        
        # 构建会话历史信息
        history_context = ""
        if conversation_history:
            # 简化历史对话，只保留时间和消息内容
            simplified_history = []
            for msg in conversation_history[-5:]:  # 只取最近5条
                simplified_msg = {
                    "timestamp": msg.get("timestamp", ""),
                    "user_message": msg.get("message", "")
                }
                simplified_history.append(simplified_msg)
            
            history_context = f"""
## 💬 会话历史上下文

最近对话记录：
{json.dumps(simplified_history, ensure_ascii=False, indent=2)}

### 上下文分析要点
- 参考历史对话理解用户真实意图
- 识别可能的参数补充或澄清需求
- 考虑多轮对话中的关联性和延续性
"""
        
        # 构建任务展示信息
        api_functions_display = ""
        if api_tasks:
            api_functions_display = f"""
## 🔧 可用API函数任务

系统当前支持以下API函数操作：
"""
            for task in api_tasks:
                params_desc = task.get('params_description', '无特殊参数要求')
                api_functions_display += f"""
**{task.get('id')}** - {task.get('name')}
- 描述：{task.get('description', '暂无描述')}
- 参数要求：{params_desc}
- 任务类型：api_function
"""
        
        # 定义换行符变量，避免在f-string中使用反斜杠
        newline = chr(10)
        
        return f"""
# 🤖 智能意图识别与任务拆解专家

你是一位专业的智能助手专家，具备深度理解用户需求、智能拆解复杂任务、准确识别多重意图、智能生成SQL语句的能力。

## 🎯 核心任务：智能意图识别与任务拆解

**用户输入**："{user_input}"

**任务**：请深度分析用户输入，智能识别意图并进行合理的任务拆解。

## 🏢 业务领域上下文

**业务领域**：{business_domain}

## 🧠 智能任务拆解核心原则

### 1. 自主分析原则
- **深度语义理解**：理解用户输入的完整语义和真实业务意图
- **智能需求拆解**：根据语义分析，将复杂需求拆解为可执行的具体任务
- **上下文感知**：结合会话历史和业务场景进行分析
- **意图完整性**：识别用户的完整需求，不遗漏任何意图

### 2. 任务拆解策略
- **多维度分析识别**：当用户表达类似"分别从A、B、C三个方面"时，应拆解为多个独立的数据查询任务
- **数据可视化拆解**：当用户要求图表时，拆解为数据查询+图表生成两个任务
- **报告生成拆解**：当用户要求报告时，拆解为多个数据查询+报告编译任务
- **复杂分析拆解**：将复杂的分析需求分解为多个相关的子任务

### 3. 任务依赖关系分析
- **识别串行依赖**：图表生成依赖数据查询，报告编译依赖多个数据查询
- **识别并行任务**：多个数据查询任务之间通常是独立的，可以并行执行
- **建立数据流**：通过input_from和output_for字段建立任务间的数据流

### 4. 上下文延续与用户偏好
- 当用户输入包含"继续""上一个""同样维度"等表述时，应基于会话历史继承上一轮的dataset_id、筛选条件、时间范围等上下文参数
- 遇到歧义时设置 next_action = "clarify" 并通过 missing_params 明确需要澄清的内容
- 优先考虑用户档案与会话偏好（如常用数据集、偏好图表类型）进行合理默认

## 👤 用户档案信息

当前用户档案：
{json.dumps(user_profile, ensure_ascii=False, indent=2) if user_profile else "- 未提供用户档案信息"}

### 权限认证说明
- 用户档案包含角色、权限、部门等关键信息
- 数据查询需要确认用户是否有数据访问权限
- 高风险操作需要特殊权限验证

{history_context}

{datasets_info}

{sql_generation_rules}

{api_functions_display}

## 🎯 智能意图识别与任务拆解规则

### 支持的意图类型

#### **1. API函数调用 (api_function)**
- **特点**：明确的业务操作，调用外部系统接口
- **匹配方式**：在available_tasks中查找task_type为"api_function"的任务
- **示例**：查询成绩、选课、退课、修改密码等
- **拆解策略**：通常不需要拆解，单一业务操作
- **参数处理**：
  - 参数齐全：next_action = "execute"
  - 缺少参数：next_action = "ask_params"，通过missing_params列出缺少的参数
  - 高风险操作：next_action = "confirm"，需要用户确认
- **输出要求**：必须指定task_id和api_function_id
- **匹配规则**：
  - 如无法精确匹配，再按name与用户输入进行关键词模糊匹配
  - 若仍无法匹配，避免生成api_function意图，改为unknown并设置next_action = "clarify"，在user_message中询问并指出可选的api函数
- **参数校验**：如果available_tasks提供了参数schema，应根据schema提取extracted_params，并将缺失部分写入missing_params
- **语言要求**：当需要与用户交互时，user_message必须使用中文

#### **2. 数据查询 (data_query)**
- **特点**：纯数据检索和分析，不修改数据
- **适用场景**：统计、分析、查看、显示数据等

#### **3. 知识库查询 (knowledge_query)**
- **特点**：从知识库中检索相关信息，基于用户问题进行智能匹配
- **适用场景**：
  - 询问业务规则、政策、流程等
  - 寻求操作指导、帮助文档
  - 查询常见问题解答
  - 获取专业知识、技术文档
  - 了解产品功能、使用方法
- **触发关键词**：
  - 询问类："如何"、"怎么"、"什么是"、"为什么"、"能否"、"可以吗"
  - 帮助类："帮助"、"指导"、"教程"、"说明"、"文档"
  - 规则类："规定"、"政策"、"流程"、"标准"、"要求"
  - 知识类："介绍"、"解释"、"原理"、"概念"、"定义"
- **与数据查询的区分标准**：
  - **知识库查询**：询问概念、规则、方法、流程等抽象知识
    - 示例："如何提高销售业绩？"、"什么是客户生命周期？"、"销售流程是怎样的？"
  - **数据查询**：查询具体的数据记录、统计结果、分析报告
    - 示例："销售业绩数据"、"客户数量统计"、"销售流程执行情况"
  - **判断要点**：
    - 如果用户询问的是"怎么做"、"是什么"、"为什么"等概念性问题 → knowledge_query
    - 如果用户询问的是具体数据、统计结果、分析报告 → data_query
    - 如果用户询问"有多少"、"哪些"、"什么时候"等具体信息 → data_query
- **拆解策略**：通常不需要拆解，单一知识检索操作
- **参数处理**：
  - 问题明确：next_action = "execute"
  - 问题模糊：next_action = "clarify"，请求用户澄清具体问题
- **智能关键词提取与扩展策略**：
  - **核心词识别**：从 query_text 中抽取主题词、动作词、对象词，移除停用词
  - **同义词扩展**：为核心词生成2-4个同义/变体（例："学籍变更"→"学籍调整"/"学籍修改"/"学籍异动"/"学籍转换"）
  - **动作词映射**：将问询动作转换为业务动作（例："怎么办"→"流程"/"申请"/"办理"）
  - **领域词汇增强**：
    * 行政词汇：申请→办理/手续、流程→步骤/程序、审批→审核/批准
    * 通用词汇：查询→检索/查看、修改→更改/变更、删除→取消/撤销
  - **关键词权重分配**：
    * 主题词（权重3）：核心业务词汇，如"学籍"、"选课"、"成绩"
    * 动作词（权重2）：操作类词汇，如"申请"、"查询"、"修改"
    * 修饰词（权重1）：限定词汇，如"流程"、"规定"、"要求"
  - 将扩展后的关键词写入 search_keywords，建议 5-12 个，按权重排序

+ **关键词分类与过滤策略**：
  - 将关键词分为两类：
    - 核心关键词（core_keywords）：主题性、领域性强的词（如："选课"、"学籍变更"、"绩效考核"）
    - 通用关键词（generic_keywords）：泛化词（如："指南"、"流程"、"操作"、"说明"、"帮助"、"教程"、"方法"、"步骤"、"规定"、"政策"）
  - 生成SQL时：
    - WHERE 过滤仅使用核心关键词（core_keywords）
    - 排序相关性可使用全部关键词（核心+通用）参与 MATCH 计算
    - 当无法识别任何核心关键词时：设置 next_action = "clarify"，在 user_message 中以中文请用户给出更具体的主题词
- **SQL生成要求**：
  - 必须生成SQL语句查询知识库表（dk_knowledge_base 与 dk_knowledge_items），表别名建议 kb 与 ki
  - **权限控制（重要）**：必须在WHERE条件中加入知识库权限过滤，只查询用户有权限的知识库
    - 用户有权限的知识库ID列表：{accessible_knowledge_bases}
    - 如果权限列表为空，则用户没有权限访问任何知识库，应返回无结果并提示
    - 如果权限列表不为空，必须在WHERE条件中添加：kb.id IN ({",".join(map(str, accessible_knowledge_bases)) if accessible_knowledge_bases else "0"})
  - **优化智能匹配策略**（兼容全文索引限制）：
    - **策略1：基础全文匹配**（主查询，适用所有情况）：
      * 统一使用：`MATCH(ki.title, ki.content, ki.summary) AGAINST('权重分级关键词' IN BOOLEAN MODE)`
      * 注意：必须使用组合字段匹配，因为全文索引建立在(title, content, summary)组合上
      * **🔥 关键词权重分级**（重要优化）：
        - **核心关键词（权重>2）**：主题性、领域性强的词，使用 `词>3` 或 `词>2` 提升权重
        - **重要关键词（权重>1.5）**：业务相关词，使用 `词>1.5` 提升权重  
        - **通用关键词（默认权重1）**：流程、步骤、程序、方法、指南等泛化词，不加修饰符
        - **权重示例**：`'离校>3 手续>2 办理>2 申请>2 指导>1.5 流程 步骤 程序'`
        - **核心词必选**：对最关键的主题词可使用 `+词>3` 确保必须包含且高权重
    - **策略2：精准组合匹配**（核心关键词≥3个时）：
      * 主题词强制匹配：`MATCH(ki.title, ki.content, ki.summary) AGAINST('+主题词>3' IN BOOLEAN MODE)`
      * 副关键词灵活组合：多个`MATCH(ki.title, ki.content, ki.summary) AGAINST('副词1>2 副词2>1.5 通用词' IN BOOLEAN MODE)`的OR连接
      * 权重组合示例：["请假", "流程", "申请", "办理"] → `MATCH(ki.title, ki.content, ki.summary) AGAINST('+请假>3' IN BOOLEAN MODE) AND (MATCH(ki.title, ki.content, ki.summary) AGAINST('流程 步骤 程序' IN BOOLEAN MODE) OR MATCH(ki.title, ki.content, ki.summary) AGAINST('申请>2 办理>2 手续>1.5' IN BOOLEAN MODE))`
    - **策略3：同义词扩展匹配**（增强召回）：
      * 包含同义词的权重匹配：`MATCH(ki.title, ki.content, ki.summary) AGAINST('主词>3 同义词1>2 同义词2>1.5 通用词' IN BOOLEAN MODE)`
      * 权重扩展示例："请假"扩展为"请假>3 休假>2 假期>2 缺勤>1.5 流程 步骤"
    - **策略4：标签增强匹配**：
      * JSON标签精确匹配：`JSON_CONTAINS(ki.tags, JSON_QUOTE('核心词'))`
      * 结合全文匹配：用OR连接提供额外召回
    - **相关性阈值过滤**（重要）：
      * 添加相关性阈值条件：`AND MATCH(ki.title, ki.content, ki.summary) AGAINST('权重分级关键词' IN BOOLEAN MODE) > 5.0`
      * 固定阈值设置：统一使用 5.0 作为标准相关性阈值，确保高质量匹配结果
      * 避免返回无关内容污染AI判断
    - **🔥 权重分级实战示例**：
      * **原始关键词**：`'离校 手续 办理 流程 步骤 程序 申请 指导'` （所有词权重=1，OR关系）
      * **权重优化后**：`'离校>3 手续>2 办理>2 申请>2 指导>1.5 流程 步骤 程序'`
      * **分级说明**：
        - `离校>3`：核心主题词，最高权重
        - `手续>2 办理>2 申请>2`：重要业务词，中等权重
        - `指导>1.5`：相关词，轻微提升权重
        - `流程 步骤 程序`：通用词，默认权重（权重=1）
      * **优化效果**：相关性计算更准确，核心主题匹配的文档排名显著提升
    - **选择与组合原则**：
      * 核心词≤2个：使用策略1（基础全文匹配）+ 策略4（标签增强）
      * 核心词≥3个：使用策略2（精准组合匹配）+ 策略3（同义词扩展）
      * 所有情况：必须添加相关性阈值过滤，必须使用权重分级
      * 简化结构：不使用多字段权重计算，避免索引兼容问题
  - **简化相关性排序**（兼容索引限制）：
    - **主要相关性**：relevance = MATCH(ki.title, ki.content, ki.summary) AGAINST('权重分级关键词' IN BOOLEAN MODE)（在SELECT中计算）
    - **业务权重**：ki.priority（内容优先级）、ki.view_count（查看热度）
    - **时效性**：ki.updated_at（更新时间）
    - **综合排序**：ORDER BY relevance DESC, ki.priority DESC, ki.view_count DESC, ki.updated_at DESC
    - **相关性阈值**：WHERE条件中必须包含 `AND relevance > 5.0`（固定高阈值，确保返回高质量匹配结果）
  - 使用 status 字段作为启用标识（示例：kb.status = 1 AND ki.status = 1）
- **输出要求**：
  - 必须指定 query_text（用户的原始问题）、search_keywords（提取的关键词）和 generated_sql（知识库查询SQL）
  - 建议补充：relevance_strategy、fallback_used、clarify_suggestions（中文）
- **权限控制处理**：
  - 如果用户有权限的知识库列表为空（{accessible_knowledge_bases}），应：
    - 设置 next_action = "clarify"
    - 在 user_message 中用中文提示："您当前没有权限访问任何知识库，请联系管理员为您分配相应的访问权限。"
    - generated_sql 设置为空字符串或注释说明无权限
- **简单澄清策略**：
  - 当问题过于模糊或关键词不明确时，可设置 next_action = "clarify"
  - 在 user_message 中用中文提出具体的澄清问题，帮助用户优化查询条件
  - **查询示例（兼容索引限制，包含权限控制和相关性过滤）**：
    
    **示例1：简单查询，基础全文匹配**
    ```sql
    -- 核心词：["学籍", "变更"]，同义词：["学籍", "变更", "学生档案", "调整", "修改", "转换"]
    -- 权重分级：学籍>3 变更>3（核心关键词），学生档案>2 调整>2 修改>2（重要关键词），转换（通用关键词）
    SELECT kb.name AS knowledge_base_name,
           ki.title, ki.content, ki.summary, kb.category, ki.tags,
           ki.priority, ki.view_count, ki.updated_at,
           MATCH(ki.title, ki.content, ki.summary) AGAINST('学籍>3 变更>3 学生档案>2 调整>2 修改>2 转换' IN BOOLEAN MODE) AS relevance
    FROM dk_knowledge_items ki
    JOIN dk_knowledge_base kb ON kb.id = ki.knowledge_base_id
    WHERE kb.status = 1 AND ki.status = 1 
      AND kb.id IN ({",".join(map(str, accessible_knowledge_bases)) if accessible_knowledge_bases else "0"})
      AND (
        (MATCH(ki.title, ki.content, ki.summary) AGAINST('学籍>3 变更>3 学生档案>2 调整>2 修改>2 转换' IN BOOLEAN MODE) > 5.0)
        OR JSON_CONTAINS(ki.tags, JSON_QUOTE('学籍'))
        OR JSON_CONTAINS(ki.tags, JSON_QUOTE('变更'))
      )
    ORDER BY relevance DESC, ki.priority DESC, ki.view_count DESC, ki.updated_at DESC
    LIMIT 5;
    ```
    
    **示例2：复杂查询，组合精准匹配**
    ```sql
    -- 核心词：["请假", "流程", "申请", "办理"]，扩展后：["请假", "休假", "假期", "流程", "步骤", "程序", "申请", "办理", "手续"]
    -- 权重分级：请假>3 休假>2 假期>2（核心主题词），申请>2 办理>2 手续>1.5（重要关键词），流程 步骤 程序（通用词）
    SELECT kb.name AS knowledge_base_name,
           ki.title, ki.content, ki.summary, kb.category, ki.tags,
           ki.priority, ki.view_count, ki.updated_at,
           MATCH(ki.title, ki.content, ki.summary) AGAINST('请假>3 休假>2 假期>2 申请>2 办理>2 手续>1.5 流程 步骤 程序' IN BOOLEAN MODE) AS relevance
    FROM dk_knowledge_items ki
    JOIN dk_knowledge_base kb ON kb.id = ki.knowledge_base_id
    WHERE kb.status = 1 AND ki.status = 1 
      AND kb.id IN ({",".join(map(str, accessible_knowledge_bases)) if accessible_knowledge_bases else "0"})
      AND (
        -- 策略2：主题词必须匹配，使用权重增强
        (MATCH(ki.title, ki.content, ki.summary) AGAINST('+请假>3' IN BOOLEAN MODE) OR MATCH(ki.title, ki.content, ki.summary) AGAINST('+休假>2' IN BOOLEAN MODE)) 
        AND (
          -- 副关键词组合匹配，通用词无权重修饰
          MATCH(ki.title, ki.content, ki.summary) AGAINST('流程 步骤 程序' IN BOOLEAN MODE) > 5.0
          OR MATCH(ki.title, ki.content, ki.summary) AGAINST('申请>2 办理>2 手续>1.5' IN BOOLEAN MODE) > 5.0
        )
        -- 策略4：标签增强匹配
        OR JSON_CONTAINS(ki.tags, JSON_QUOTE('请假'))
        OR JSON_CONTAINS(ki.tags, JSON_QUOTE('假期'))
      )
    ORDER BY relevance DESC, ki.priority DESC, ki.view_count DESC, ki.updated_at DESC
    LIMIT 5;
    ```

### 🔍 **重要：查询意图类型智能识别**

#### **A. 简单数据获取 (响应样式是data_only时)**
**触发关键词**：
- 查看、显示、列出、展示、获取、看看、给我
- 明细、详细信息、具体信息、原始数据
- 有哪些、都有什么、包含什么
- 查询、检索、提取
- 哪个、哪些、什么（用于直接问答）

**用户意图特征**：
- 只想获得数据明细或直接答案，不需要深度分析
- 使用平铺直叙的表达，没有分析性词汇
- 关注具体的数据内容而非数据模式
- **重要**：包含"最多、最少、最高、最低"等词汇时，如果是简单的"哪个/什么...最..."句型，仍属于简单查询

**示例**：
- "查看销售订单明细"
- "显示所有学生信息"  
- "列出2023年1月的交易记录"
- "给我产品库存数据"
- "哪个班级人最多"  ✅ **关键示例**
- "什么产品销量最高"
- "哪个学生成绩最好"

**处理策略**：
- 响应样式是"data_only"时
- 不自动生成AI解读和图表
- 直接返回数据明细，保持简洁

#### **B. 数据分析需求 (query_style: "analytical")**  
**触发关键词**：
- 分析、统计、计算、对比、比较
- 趋势、分布、模式、规律、特征
- 占比、比例、增长、变化、差异
- 排名、排序（当用于复杂分析时）

**用户意图特征**：
- 需要从数据中获得洞察和结论
- 使用分析性、探索性词汇
- 关注数据背后的规律和模式
- **重要**：包含"最多、最少、最高、最低"等词汇时，如果需要深度分析、对比、解释原因，则属于分析查询

**示例**：
- "分析销售趋势"
- "统计各地区销量分布"
- "比较不同产品的销售情况"
- "计算各月份增长率"
- "分析各班级人数分布情况，找出人数最多和最少的班级并解释原因"  ✅ **与简单查询的区别**
- "统计排名前10的销售员业绩情况"

**区分关键**：
- 简单查询："哪个班级人最多" → 只要结果，不要分析
- 分析查询："分析班级人数分布，找出最多和最少的原因" → 要分析和解释

**处理策略**：
- query_style = "analytical"
- response_style = "full_analysis"
- 自动生成数据分析和图表
- 提供深度分析和洞察

**拆解策略**：
  - **多维度分析**：如"分别从销售员、地区、产品类别三个方面统计"→ 3个独立查询任务
  - **复杂统计**：按统计类型拆解为多个查询
  - **条件筛选**：按筛选条件拆解为多个查询
- **示例**：
  - 简单查询：统计班级人数 → 1个查询意图
  - 多维度分析：分别按销售员、地区、产品类别统计 → 3个查询意图
  - 复杂分析：分析学生成绩分布、专业分布、地区分布 → 3个查询意图
- **参数处理**：
  - 查询条件齐全：next_action = "execute"
  - 查询条件不明确：next_action = "ask_params"，询问具体的查询条件
- **🔍 重要：智能字符串匹配策略**：
  - **问题描述**：用户输入"四川"但数据库存储"四川省"，导致 `WHERE 所在省份 = '四川'` 查询不到结果
  - **解决原则**：对于文本类字段的匹配，优先使用LIKE模糊匹配而非精确等于
  - **地名标准化匹配**：
    * 用户输入"四川" → 生成 `WHERE 所在省份 LIKE '%四川%'` 而不是 `= '四川'`
    * 用户输入"北京" → 生成 `WHERE 所在地区 LIKE '%北京%'`，匹配"北京市"
    * 用户输入"上海" → 生成 `WHERE 城市 LIKE '%上海%'`，匹配"上海市"、"上海浦东"
  - **专业名称匹配**：
    * 用户输入"计算机" → 生成 `WHERE 专业名称 LIKE '%计算机%'`，匹配"计算机科学与技术"
    * 用户输入"英语" → 生成 `WHERE 专业 LIKE '%英语%'`，匹配"英语专业"、"商务英语"
    * 用户输入"会计" → 生成 `WHERE 专业 LIKE '%会计%'`，匹配"会计学"、"会计电算化"
  - **学校名称匹配**：
    * 用户输入"清华" → 生成 `WHERE 学校名称 LIKE '%清华%'`，匹配"清华大学"
    * 用户输入"北大" → 生成 `WHERE 学校 LIKE '%北大%' OR 学校 LIKE '%北京大学%'`
  - **通用匹配原则**：
    * **默认使用LIKE**：对于所有文本类字段的WHERE条件，除非用户明确要求精确匹配，否则使用LIKE '%关键词%'
    * **多关键词处理**：如"计算机专业"，使用 `LIKE '%计算机%' AND LIKE '%专业%'`
    * **数值字段例外**：年龄、分数、数量等数值字段仍使用精确匹配或范围匹配
  - **具体应用示例**：
    * ❌ 错误：`WHERE 所在省份 = '四川'`（无法匹配"四川省"）
    * ✅ 正确：`WHERE 所在省份 LIKE '%四川%'`（能匹配"四川省"）
    * ❌ 错误：`WHERE 专业名称 = '计算机'`（无法匹配"计算机科学与技术"）
    * ✅ 正确：`WHERE 专业名称 LIKE '%计算机%'`（能匹配相关专业）
- **输出要求**：指定dataset_id和generated_sql，包含query_style和response_style字段，SQL中必须应用智能匹配策略

#### **4. 未知意图 (unknown)**
- **触发条件**：无法明确识别为以上任何类型
- **处理方式**：next_action = "clarify"，请求用户澄清需求或提供操作建议
- **常见情况**：
  - 用户表达不清楚
  - 涉及系统不支持的功能
  - 需求过于复杂需要分解

### 🔍 智能拆解分析要点

#### **多维度分析智能识别**
- 当用户使用"分别从...方面"、"按照...分别"、"各个维度"等表达时
- 理解用户想要的是多个独立的分析视角
- 每个维度应该生成独立的数据查询任务
- 每个查询具有相同的筛选条件和统计字段，但GROUP BY字段不同

#### **复杂业务场景拆解**
- 分析用户的完整业务需求
- 将复杂需求分解为可执行的子任务
- 建立子任务之间的逻辑关系
- 确定子任务的执行顺序

#### **智能图表生成说明**
- 当数据适合可视化时，AI会在回复中自动生成ECharts图表
- 无需单独拆解图表生成任务，图表作为数据查询结果的增强展示
- 系统根据数据类型和用户问题自动选择最合适的图表类型

#### **SQL智能生成**
- 根据用户需求和数据集结构生成SQL语句
- 确保SQL语法正确且可直接执行
- 禁止使用SELECT *；仅当query_style为"simple"且response_style为"data_only"，同时用户未明确字段时方可使用SELECT *，其余场景必须显式列出字段
- 考虑性能优化，合理使用LIMIT等限制
- 针对多维度分析生成多个独立的GROUP BY查询
- **🚨 关键：智能字符串匹配策略**：
  - **核心问题**：用户输入"四川"，数据库存储"四川省"，使用 `= '四川'` 会导致查询无结果
  - **解决方案**：对文本字段统一使用LIKE模糊匹配替代精确等于匹配
  - **应用规则**：
    * 地名：`LIKE '%四川%'`（匹配"四川省"）、`LIKE '%北京%'`（匹配"北京市"）
    * 专业：`LIKE '%计算机%'`（匹配"计算机科学与技术"）
    * 学校：`LIKE '%清华%'`（匹配"清华大学"）
    * 多词组合：`LIKE '%计算机%' AND LIKE '%专业%'`
  - **例外情况**：数值、日期、状态等字段仍使用精确匹配
  - **SQL生成要求**：在generated_sql中，所有文本类WHERE条件必须使用LIKE '%关键词%'模式

## 📤 输出格式规范

请返回JSON数组格式，支持复杂需求的智能拆解和多个意图的并发识别：

```json
[
  {{
    "intent_id": "意图唯一标识符",
    "intent_type": "api_function | data_query | knowledge_query | unknown",
    "task_name": "任务名称",
    "task_id": "匹配的任务配置ID（api_function类型必填）",
    "api_function_id": "API函数ID（api_function类型必填）",
    "dataset_id": "数据集ID（data_query类型必填）",
    "generated_sql": "智能生成的SQL语句（data_query和knowledge_query类型必填）",
    "query_style": "simple | analytical（data_query类型必填，simple=简单数据获取，analytical=数据分析需求）",
    "priority": "优先级1-10（仅intent_type等于data_query,并且query_style等于analytical时需要）",
    "execution_order": "执行顺序1-10（仅intent_type等于data_query,并且query_style等于analytical时需要）",
    "dependencies": ["依赖的其他意图ID列表（仅intent_type等于data_query,并且query_style等于analytical时需要）"],
    "response_style": "data_only | full_analysis（data_query类型必填，data_only=仅返回数据明细，full_analysis=包含数据分析和图表）",
    "query_text": "用户的原始问题（knowledge_query类型必填）",
    "search_keywords": ["从问题中提取的关键词列表（knowledge_query类型必填）"],
    "extracted_params": {{
      "参数名": "参数值"
    }},
    "missing_params": [
      {{
        "param_name": "参数名",
        "param_type": "参数类型",
        "is_required": true/false,
        "prompt_question": "追问问题"
      }}
    ],

    "input_from": "输入数据来源任务ID（可选）",
    "output_for": ["输出数据给哪些任务使用（可选）"],
    "analysis_reason": "详细的意图识别和任务拆解分析过程(仅intent_type等于data_query,并且query_style等于analytical时需要)",
    "next_action": "execute | ask_params | confirm | clarify",
    "user_message": "直接返回给用户的完整响应消息（当next_action为ask_params、confirm、clarify时必填）"
  }}
]
```

## 🎯 智能拆解执行指令

### 1. 深度语义理解
- 理解用户输入的完整语义和业务意图
- 识别隐含的多重需求和复杂关系
- 分析用户的真实目标和期望结果

### 2. 智能需求拆解
- 将复杂需求拆解为可执行的具体任务
- 识别多维度分析需求并拆解为独立查询
- 自动组合数据查询与可视化/报告生成

### 3. 任务关系分析
- 识别任务间的依赖关系和执行顺序
- 建立任务间的数据流和输入输出关系
- 优化任务执行计划和资源分配

### 4. 参数智能提取
- 从用户输入中提取所有可用参数
- 识别缺失参数并生成合理的追问
- 结合上下文补全参数信息

### 5. SQL智能生成
- 根据拆解结果生成对应的SQL语句
- 确保SQL语法正确且可直接执行
- 优化查询性能和结果准确性

## 🚀 拆解示例和指导

### 多维度分析示例
**用户输入**："分别从销售员、地区、产品类别三个方面统计2023年销量和金额"

**智能分析**：
- 识别为多维度分析需求
- 需要3个独立的数据查询任务
- 每个任务具有相同的时间条件和统计字段
- 但GROUP BY字段不同

**期望拆解结果**：
```json
[
  {{
    "intent_id": "query_001",
    "intent_type": "data_query",
    "task_name": "按销售员统计2023年销量和金额",
    "dataset_id": "销售数据集",
    "generated_sql": "SELECT 销售员, SUM(销售数量) AS 销售数量, SUM(总金额) AS 总金额 FROM sales_table WHERE 销售日期 BETWEEN '2023-01-01' AND '2023-12-31' GROUP BY 销售员 ORDER BY 总金额 DESC",
    "query_style": "analytical",
    "response_style": "full_analysis"
  }},
  {{
    "intent_id": "query_002", 
    "intent_type": "data_query",
    "task_name": "按地区统计2023年销量和金额",
    "dataset_id": "销售数据集",
    "generated_sql": "SELECT 地区, SUM(销售数量) AS 销售数量, SUM(总金额) AS 总金额 FROM sales_table WHERE 销售日期 BETWEEN '2023-01-01' AND '2023-12-31' GROUP BY 地区 ORDER BY 总金额 DESC",
    "query_style": "analytical",
    "response_style": "full_analysis"
  }},
  {{
    "intent_id": "query_003",
    "intent_type": "data_query",
    "task_name": "按产品类别统计2023年销量和金额",
    "dataset_id": "销售数据集",
    "generated_sql": "SELECT 产品类别, SUM(销售数量) AS 销售数量, SUM(总金额) AS 总金额 FROM sales_table WHERE 销售日期 BETWEEN '2023-01-01' AND '2023-12-31' GROUP BY 产品类别 ORDER BY 总金额 DESC",
    "query_style": "analytical",
    "response_style": "full_analysis"
  }}
]
```

### 数据查询示例
**用户输入**："查询各专业学生分布情况"

**智能分析**：
- 识别为数据查询需求
- 系统会自动在回复中生成合适的图表展示
- 只需要一个数据查询任务

**期望拆解结果**：
```json
[
  {{
    "intent_id": "query_001",
    "intent_type": "data_query",
    "task_name": "查询各专业学生分布数据",
    "dataset_id": "学生信息数据集",
    "generated_sql": "SELECT major, COUNT(*) as student_count FROM students GROUP BY major ORDER BY student_count DESC",
    "query_style": "analytical",
    "response_style": "full_analysis"
  }}
]
```

### 智能字符串匹配示例
**用户输入**："四川有多少学生"

**智能分析**：
- 识别为数据查询需求
- 关键词："四川"、"学生"、"多少"
- **应用智能匹配**：用户输入"四川"，但数据库可能存储"四川省"

**期望拆解结果**：
```json
[
  {{
    "intent_id": "query_001",
    "intent_type": "data_query",
    "task_name": "查询四川地区学生数量",
    "dataset_id": "学生信息数据集",
    "generated_sql": "SELECT COUNT(*) AS student_count FROM students WHERE `所在省份` LIKE '%四川%'",
    "query_style": "simple",
    "response_style": "data_only"
  }}
]
```

**关键改进**：
- ❌ **错误写法**：`WHERE 所在省份 = '四川'`（无法匹配"四川省"）
- ✅ **正确写法**：`WHERE 所在省份 LIKE '%四川%'`（能匹配"四川省"、"四川市"等）

**更多智能匹配示例**：
- 用户输入"计算机专业有多少人" → `WHERE 专业名称 LIKE '%计算机%'`（匹配"计算机科学与技术"）
- 用户输入"清华大学的学生" → `WHERE 学校名称 LIKE '%清华%'`（匹配"清华大学"）
- 用户输入"北京的学生分布" → `WHERE 所在地区 LIKE '%北京%'`（匹配"北京市"）
- 用户输入"英语专业成绩" → `WHERE 专业 LIKE '%英语%'`（匹配"英语专业"、"商务英语"）

### 简单数据查询示例
**用户输入**："显示所有学生信息"

**智能分析**：
- 识别为简单数据获取需求（没有分析性词汇）
- 用户只想查看数据明细，不需要AI解读和图表
- 系统将直接返回数据，保持简洁

**期望拆解结果**：
```json
[
  {{
    "intent_id": "query_001",
    "intent_type": "data_query",
    "task_name": "显示所有学生信息",
    "dataset_id": "学生信息数据集",
    "generated_sql": "SELECT * FROM students ORDER BY student_id",
    "query_style": "simple",
    "response_style": "data_only"
  }}
]
```

### 知识库查询示例
**用户输入**："如何申请学籍变更？"

**智能分析**：
- 识别为知识库查询需求（包含"如何"关键词）
- 用户寻求操作指导和流程说明
- 需要从知识库中检索相关政策和流程信息
- 生成SQL查询知识库表

**期望拆解结果**：
```json
[
  {{
    "intent_id": "knowledge_001",
    "intent_type": "knowledge_query",
    "task_name": "查询学籍变更申请流程",
          "query_text": "如何申请学籍变更？",
      "search_keywords": ["学籍变更", "申请", "流程", "办理", "学生档案", "调整", "修改", "手续"],
      "generated_sql": "SELECT kb.name AS knowledge_base_name, ki.title, ki.content, ki.summary, kb.category, ki.tags, ki.priority, ki.view_count, ki.updated_at, MATCH(ki.title, ki.content, ki.summary) AGAINST('学籍变更>3 申请>2 办理>2 学生档案>2 调整>2 修改>2 手续>1.5 流程' IN BOOLEAN MODE) AS relevance FROM dk_knowledge_items ki JOIN dk_knowledge_base kb ON kb.id = ki.knowledge_base_id WHERE kb.status = 1 AND ki.status = 1 AND kb.id IN (1,2,3) AND (MATCH(ki.title, ki.content, ki.summary) AGAINST('学籍变更>3 申请>2 办理>2 学生档案>2 调整>2 修改>2 手续>1.5 流程' IN BOOLEAN MODE) > 5.0 OR JSON_CONTAINS(ki.tags, JSON_QUOTE('学籍变更')) OR JSON_CONTAINS(ki.tags, JSON_QUOTE('申请'))) ORDER BY relevance DESC, ki.priority DESC, ki.view_count DESC, ki.updated_at DESC LIMIT 5;"
  }}
]
```

### 🎯 意图识别边界情况处理

#### **混合意图识别**
当用户输入同时包含数据查询和知识库查询特征时：
- **优先级判断**：根据用户的主要意图进行分类
- **示例分析**：
  - "销售数据怎么分析？" → knowledge_query（询问分析方法）
  - "分析销售数据" → data_query（执行数据分析）
  - "如何查看销售报表？" → knowledge_query（询问操作方法）
  - "查看销售报表" → data_query（查看具体数据）

#### **关键词重叠处理**
某些关键词可能同时适用于两种意图：
- **"查询"关键词**：
  - "查询学生信息" → data_query（查看数据）
  - "查询如何修改学生信息" → knowledge_query（询问操作方法）
- **"分析"关键词**：
  - "分析销售数据" → data_query（数据分析）
  - "如何分析销售数据" → knowledge_query（询问分析方法）

#### **判断优先级规则**
1. **疑问词优先**：包含"如何"、"怎么"、"为什么"等疑问词 → knowledge_query
2. **动作词判断**：
   - 直接动作（"查看"、"显示"、"统计"）→ data_query
   - 询问动作（"如何查看"、"怎么显示"）→ knowledge_query
3. **目标对象**：
   - 具体数据对象（"销售数据"、"学生名单"）→ data_query
   - 抽象概念对象（"销售策略"、"管理制度"）→ knowledge_query

    ## 🚨 重要输出要求

    **输出格式要求**：
    - 只返回JSON数组格式的结果
    - 不要添加任何分析说明、前言、后语或补充说明
    - 不要使用markdown格式
    - 不要添加"```json"代码块标记
    - 直接输出可解析的JSON数组

    **禁止输出的内容**：
    - ❌ 任何形式的分析说明文字
    - ❌ "基于用户提供的输入信息..."等开场白
    - ❌ "### 意图识别分析"等标题
    - ❌ "### 任务拆解"等说明
    - ❌ "### 补充说明"等额外信息
    - ❌ markdown格式的文本内容
    - ❌ 省略号或占位符（如"..."、"N/A"、"TBD"）

    **正确输出示例**：
    [{{"intent_id": "query_001", "intent_type": "data_query", ...}}]

    **开始输出纯JSON结果** ⬇️
"""

    @staticmethod
    def build_assistant_response_prompt(
        user_question: str, 
        assistant_result: dict, 
        conversation_context: dict = None
    ) -> str:
        """
        构建智能助手响应结果的回复提示词
        专门用于处理chat_with_assistant接口返回的结果，生成用户友好的回复消息
        
        参数:
            user_question (str): 用户原始问题
            assistant_result (dict): chat_with_assistant接口返回的结果
            conversation_context (dict, optional): 会话上下文信息
            
        返回:
            str: 用于生成用户友好回复的提示词
        """
        
        # 解析智能助手返回结果
        status = assistant_result.get('status', 'unknown')
        main_message = assistant_result.get('message', '')
        response_type = assistant_result.get('response_type', 'unknown')
        summary = assistant_result.get('summary', {})
        results = assistant_result.get('results', [])
        intent_context = assistant_result.get('intent_context', {})
        
        # 🎯 新增：解析查询类型和响应样式
        query_style = intent_context.get('query_style', 'analytical')
        response_style = intent_context.get('response_style', 'full_analysis')
        
        # 判断是否为简单数据查询（仅需要数据，不需要AI解读）
        is_simple_data_query = (query_style == "simple" and response_style == "data_only")
        
        # 分析执行状态
        if status == "success":
            execution_status = "✅ 执行成功"
            status_analysis = "所有任务都已成功完成"
        elif status == "partial_success":
            execution_status = "⚠️ 部分成功"
            total_tasks = summary.get('total_tasks', 0)
            success_count = summary.get('success_count', 0) 
            failed_count = summary.get('failed_count', 0)
            status_analysis = f"总计{total_tasks}个任务，{success_count}个成功，{failed_count}个失败"
        elif status == "error":
            execution_status = "❌ 执行失败"
            status_analysis = "任务执行过程中遇到错误"
        elif status == "need_more_info":
            execution_status = "❓ 需要更多信息"
            status_analysis = "需要用户提供更多信息才能继续"
        else:
            execution_status = "❔ 状态未知"
            status_analysis = "任务执行状态不明确"
            
        # 分析回复类型
        if response_type == "parameter_request":
            reply_strategy = "参数请求回复"
            reply_focus = "友好地引导用户提供缺失的参数信息"
        elif response_type == "execution_result":
            reply_strategy = "执行结果回复"
            reply_focus = "清晰展示任务执行结果和相关数据"
        elif response_type == "error":
            reply_strategy = "错误处理回复"
            reply_focus = "简洁说明错误情况，提供适当建议"
        else:
            reply_strategy = "通用回复"
            reply_focus = "根据实际情况灵活调整回复内容"
            
        # 构建详细结果分析 - 合并任务结果和数据，避免重复
        detailed_results_analysis = ""
        failed_results = []
        
        # 构建AI解读相关数据
        ai_interpretation_data = []
        
        if results:
            detailed_results_analysis = "\n## 📊 详细执行结果分析\n"
            
            # 分别处理成功和失败的任务
            successful_tasks_with_data = []
            
            for i, result in enumerate(results, 1):
                result_status = result.get('status', 'unknown')
                task_name = result.get('task_name', f'任务{i}')
                result_message = result.get('message', '')
                intent_type = result.get('intent_type', 'unknown')
                
                if result_status == "success":
                    # 直接构建包含数据的成功任务信息
                    task_info = f"### ✅ {task_name} ({intent_type})\n"
                    task_info += f"**执行状态**: 成功完成\n"
                    task_info += f"**执行消息**: {result_message}\n"
                    
                    # 分析成功结果的数据内容
                    result_data = result.get('data', None)
                    if result_data:
                        if intent_type == "data_query":
                            if isinstance(result_data, dict):
                                dataset_name = result_data.get('dataset_name', '未知数据集')
                                total_rows = result_data.get('total_rows', 0)
                                columns = result_data.get('columns', [])
                                actual_data = result_data.get('data', [])
                                
                                task_info += f"**数据集**: {dataset_name}\n"
                                task_info += f"**字段数**: {len(columns)}个\n"
                                
                                if actual_data and len(actual_data) > 0:
                                    task_info += f"**实际数据**: {len(actual_data)}条记录\n"
                                    
                                    # 使用智能压缩来减少token消耗
                                    display_data = actual_data[:200]  # 限制显示数据量
                                    compression_result = DataHelp.compress_json_array_smart(display_data)
                                    
                                    if compression_result['compressed']:
                                        # 使用压缩格式
                                        compressed_data = compression_result['data']
                                        stats = compression_result['compression_stats']
                                        task_info += f"**数据内容** (压缩格式，节省{stats['compression_ratio']}% token):\n```json\n{DataHelp.to_json(compressed_data)}\n```\n"
                                    else:
                                        # 使用原始格式
                                        task_info += f"**数据内容**:\n```json\n{DataHelp.to_json(display_data)}\n```\n"
                                    
                                    if len(actual_data) > 200:
                                        task_info += f"**注意**: 仅显示前200条记录，共{len(actual_data)}条\n"
                                    
                                    # 为AI解读收集数据
                                    ai_interpretation_data.append({
                                        'task_name': task_name,
                                        'dataset_name': dataset_name,
                                        'columns': columns,
                                        'data': actual_data,
                                        'total_rows': total_rows,
                                        'data_for_analysis': display_data
                                    })
                                else:
                                    task_info += f"**数据状态**: 查询成功但无数据返回\n"
                                    
                        elif intent_type == "api_function":
                            task_info += f"**API调用结果**:\n"
                            if isinstance(result_data, dict):
                                # 对于字典类型，直接使用to_json
                                task_info += f"```json\n{DataHelp.to_json(result_data, ensure_ascii=False, indent=2)}\n```\n"
                            elif isinstance(result_data, list):
                                # 对于列表类型，尝试使用压缩
                                compression_result = DataHelp.compress_json_array_smart(result_data)
                                if compression_result['compressed']:
                                    compressed_data = compression_result['data']
                                    stats = compression_result['compression_stats']
                                    task_info += f"**压缩格式数据** (节省{stats['compression_ratio']}% token):\n```json\n{DataHelp.to_json(compressed_data)}\n```\n"
                                else:
                                    task_info += f"```json\n{DataHelp.to_json(result_data)}\n```\n"
                            else:
                                task_info += f"```json\n{DataHelp.to_json(result_data)}\n```\n"
                                
                        elif intent_type == "knowledge_query":
                            task_info += f"**知识库查询结果**:\n"
                            if isinstance(result_data, dict):
                                # 处理知识库查询的特定数据结构
                                knowledge_list = result_data.get('data', [])
                                total_found = result_data.get('total_rows', 0)
                                
                                task_info += f"**找到条目**: {total_found}条相关知识\n"
                                
                                if knowledge_list and len(knowledge_list) > 0:
                                    # 构建知识库内容的结构化展示
                                    for i, knowledge_item in enumerate(knowledge_list[:5], 1):  # 限制显示前5条
                                        title = knowledge_item.get('title', '无标题')
                                        content = knowledge_item.get('content', '')
                                        summary = knowledge_item.get('summary', '')
                                        kb_name = knowledge_item.get('knowledge_base_name', '未知知识库')
                                        tags = knowledge_item.get('tags', '')
                                        priority = knowledge_item.get('priority', 0)
                                        
                                        task_info += f"\n**📚 知识条目 {i}**：\n"
                                        task_info += f"- **标题**: {title}\n"
                                        task_info += f"- **知识库**: {kb_name}\n"
                                        
                                        # 展示摘要或内容片段
                                        if summary:
                                            task_info += f"- **摘要**: {summary}\n"
                                        elif content:
                                            content_snippet = content[:200] + "..." if len(content) > 200 else content
                                            task_info += f"- **内容片段**: {content_snippet}\n"
                                        
                                        if tags:
                                            task_info += f"- **标签**: {tags}\n"
                                        
                                        if priority > 0:
                                            task_info += f"- **优先级**: {priority}\n"
                                        
                                        if len(knowledge_list) > 5:
                                            task_info += f"\n**注意**: 显示前5条相关知识，总计{len(knowledge_list)}条\n"
                                    else:
                                        task_info += f"**查询状态**: 查询成功但未找到相关知识\n"
                                else:
                                    task_info += f"```json\n{DataHelp.to_json(result_data)}\n```\n"
                                
                        else:
                            task_info += f"**执行结果**:\n"
                            if result_data:
                                # 智能判断是否使用压缩
                                if isinstance(result_data, list):
                                    compression_result = DataHelp.compress_json_array_smart(result_data)
                                    if compression_result['compressed']:
                                        compressed_data = compression_result['data']
                                        stats = compression_result['compression_stats']
                                        task_info += f"**压缩格式数据** (节省{stats['compression_ratio']}% token):\n```json\n{DataHelp.to_json(compressed_data)}\n```\n"
                                    else:
                                        task_info += f"```json\n{DataHelp.to_json(result_data)}\n```\n"
                                else:
                                    task_info += f"```json\n{DataHelp.to_json(result_data)}\n```\n"
                    else:
                        task_info += f"**数据状态**: 无数据返回\n"
                    
                    task_info += "\n"
                    successful_tasks_with_data.append(task_info)
                        
                else:
                    failed_results.append({
                        'task_name': task_name,
                        'intent_type': intent_type,
                        'message': result_message,
                        'error': result.get('error', '未知错误')
                    })
            
            # 构建成功任务详情（已包含数据）
            if successful_tasks_with_data:
                for task_info in successful_tasks_with_data:
                    detailed_results_analysis += task_info
                    
            # 构建失败任务详情
            if failed_results:
                detailed_results_analysis += "### ❌ 执行失败的任务\n\n"
                for i, result in enumerate(failed_results, 1):
                    detailed_results_analysis += f"**{i}. {result['task_name']}** ({result['intent_type']})\n"
                    detailed_results_analysis += f"- **状态**: 执行失败\n"
                    detailed_results_analysis += f"- **错误**: {result['error']}\n"
                    detailed_results_analysis += f"- **消息**: {result['message']}\n\n"
        
        # 构建AI解读部分 - 只有分析查询才需要AI解读，简单数据查询不需要
        ai_interpretation_section = ""
        if ai_interpretation_data and not is_simple_data_query:
            ai_interpretation_section = "\n## 🤖 智能数据分析任务\n"
            ai_interpretation_section += "**🎯 核心要求**：当有数据查询结果时，请在回复中为每个数据结果生成一段数据分析**和对应的可视化图表配置**，帮助用户理解数据的含义和价值。\n\n"
            
            # 统一的数据分析要求说明
            ai_interpretation_section += """### 📋 数据分析要求说明

**数据分析**: [提供数据分析和洞察]

**数据可视化**: [为每个数据查询结果生成对应的ECharts图表配置]

**解读格式**: 使用简洁明了的语言，避免过于技术性的描述

**🎨 可视化配置要求**: 
- **必须为每个数据分析任务生成对应的ECharts图表配置**
- **位置**: 在数据分析后立即提供可视化配置
- **格式**: 使用标准的ECharts 5.x JSON配置格式
- **类型选择**: 根据数据特征选择合适的图表类型（饼图、柱状图、折线图等）

**📊 回复结构示例**:
```
## 1. [数据类别名称]

**数据分析**: [提供数据分析和洞察]

**数据可视化**:
```json
[ECharts配置JSON]
```
```

---

"""
            
            # 为每个任务提供特定信息，强调每个任务都需要独立的可视化配置
            for i, interpretation_data in enumerate(ai_interpretation_data, 1):
                task_name = interpretation_data['task_name']
                dataset_name = interpretation_data['dataset_name']
                columns = interpretation_data['columns']
                data = interpretation_data['data']
                total_rows = interpretation_data['total_rows']
                
                ai_interpretation_section += f"### 📈 数据分析任务 {i}：{task_name}\n"
                ai_interpretation_section += f"**数据集**: {dataset_name}\n"
                ai_interpretation_section += f"**数据量**: {total_rows}条记录\n"
                ai_interpretation_section += f"**字段**: {', '.join(columns)}\n"
                
                # 🎯 新增：明确要求为每个任务生成可视化配置
                ai_interpretation_section += f"**📊 可视化要求**: 请为此数据集生成一个合适的ECharts图表配置\n"
                
                # 根据数据特征推荐图表类型
                if len(data) <= 10:
                    ai_interpretation_section += f"**图表建议**: 数据条目较少({len(data)}条)，建议使用饼图或柱状图\n"
                elif len(data) <= 30:
                    ai_interpretation_section += f"**图表建议**: 数据条目适中({len(data)}条)，建议使用柱状图或条形图\n"
                else:
                    ai_interpretation_section += f"**图表建议**: 数据条目较多({len(data)}条)，建议使用聚合后的柱状图或分组图表\n"
                
                # 检查数据量，如果超过200行，提醒只分析前200行
                if len(data) > 200:
                    ai_interpretation_section += f"**数据量提醒**: 由于数据量较大({len(data)}条)，请主要基于前200条记录进行分析，或使用聚合统计的方式处理。\n"
                
                ai_interpretation_section += "\n"
        
        # 🎯 新增：构建多任务分析总结部分
        multi_task_summary_section = ""
        if ai_interpretation_data and len(ai_interpretation_data) > 1 and not is_simple_data_query:
            multi_task_summary_section = "\n## 📊 多任务分析总结\n"
            multi_task_summary_section += "**🎯 总结要求**：当存在多个数据分析任务时，请在所有单独分析完成后，提供一个综合性总结，帮助用户理解整体情况和关联性。\n\n"
            
            # 总结要求说明
            multi_task_summary_section += """### 📋 综合总结要求说明

**总结结构**：
1. **整体概览**：对所有分析任务的整体执行情况进行概述
2. **关键发现**：汇总各个任务中最重要的洞察和发现
3. **数据关联性**：分析不同数据维度之间的关联和相互影响
4. **综合洞察**：基于多维度分析提供更深层的商业洞察
5. **统一建议**：提供基于全部分析结果的综合性行动建议

**总结格式要求**：
- 采用高度概括的语言，避免重复单个任务的具体内容
- 重点关注任务间的关联性和综合价值
- 提供战略层面的洞察和建议
- 控制在100-300字以内，确保内容精炼有价值
- 采用决策者视角，突出商业价值

**📊 总结位置**：请在所有单独任务分析完成后，在最后部分添加综合总结：

```
## 综合分析总结

**整体概览**: [对所有分析任务的整体情况概述]

**关键发现**: [汇总最重要的洞察]

**数据关联性**: [分析不同维度间的关联]

**综合洞察**: [提供深层商业洞察]

**统一建议**: [基于全部分析的综合建议]
```

---

"""
            
            # 为总结提供任务信息
            task_names = [data['task_name'] for data in ai_interpretation_data]
            multi_task_summary_section += f"### 📈 待总结的分析任务（共{len(ai_interpretation_data)}个）:\n"
            for i, task_name in enumerate(task_names, 1):
                multi_task_summary_section += f"{i}. {task_name}\n"
            
            multi_task_summary_section += "\n**总结指导**：\n"
            multi_task_summary_section += f"- 这是一个涉及{len(ai_interpretation_data)}个维度的综合分析\n"
            multi_task_summary_section += "- 请重点关注不同维度数据之间的相互关系和影响\n"
            multi_task_summary_section += "- 提供能够指导整体决策的综合性洞察\n"
            multi_task_summary_section += "- 避免简单重复各个任务的结论，要提升到战略层面\n\n"
        
        # 构建参数上下文分析
        parameter_context_analysis = ""
        if response_type == "parameter_request":
            missing_params = []
            for result in results:
                if result.get('missing_params'):
                    missing_params.extend(result.get('missing_params', []))
            
            if missing_params:
                parameter_context_analysis = "\n## ❓ 缺失参数分析\n"
                parameter_context_analysis += "系统需要以下参数才能继续执行：\n\n"
                for param in missing_params:
                    param_name = param.get('param_name', '未知参数')
                    param_type = param.get('param_type', '未知类型')
                    is_required = param.get('is_required', True)
                    prompt_question = param.get('prompt_question', f'请提供{param_name}')
                    
                    parameter_context_analysis += f"- **{param_name}** ({param_type})"
                    parameter_context_analysis += f" - {'必填' if is_required else '可选'}\n"
                    parameter_context_analysis += f"  提示：{prompt_question}\n\n"

        # 构建上下文分析
        context_analysis = ""
        if conversation_context:
            context_analysis = "\n## 📝 会话上下文分析\n"
            context_analysis += "**用户需求理解**：基于用户问题和执行结果，重点关注用户的真实需求和期望\n"
            context_analysis += "**执行结果评估**：分析智能助手的执行情况，识别有价值的信息\n"
            context_analysis += "**回复重点确定**：确保回复内容直接回答用户关心的核心问题\n"

        # 🎯 根据查询类型构建不同的回复策略
        response_strategy = ""
        if status == "success":
            if is_simple_data_query:
                response_strategy = """
## 🎯 简单数据查询回复策略

### 回复结构建议：
1. **简洁开场**：确认查询完成
2. **直接展示数据**：以清晰的表格格式展示查询结果
3. **数据概况**：简要说明数据的基本信息（行数、字段等）
4. **🚫 不进行AI解读**：用户只需要数据，不需要分析
5. **🚫 不生成图表**：避免不必要的可视化
6. **🚫 不显示JSON格式**：已经用表格格式展示，无需JSON
7. **简单总结**：一句话总结查询结果

### 数据展示要求：
- **必须使用表格格式**：将数据以markdown表格形式展示
- **完整字段展示**：确保所有重要字段都能在表格中体现
- **智能字段分组**：如果字段过多，可分多个表格显示
- **限制显示行数**：表格显示前5-10行数据，避免过长
- **字段优先级**：优先显示包含关键信息的字段

### 语言要求：
- 简洁明了，直接呈现数据
- 避免过度分析和解读
- 重点是数据的准确性和完整性
- 提供基本的数据统计信息
"""
            else:
                # 检查是否包含知识库查询
                has_knowledge_query = any(
                    result.get('intent_type') == 'knowledge_query' 
                    for result in results if result.get('status') == 'success'
                )
                
                if has_knowledge_query:
                    response_strategy = """
## 🎯 知识库查询回复策略

### 回复结构建议：
1. **确认开场**：确认已找到相关知识信息
2. **知识内容展示**：清晰展示找到的知识条目
3. **内容整理**：将多个知识条目按逻辑整理成连贯回答
4. **关键信息提取**：提取最关键的信息直接回答用户问题
5. **知识来源**：适当说明信息来源于知识库
6. **补充建议**：提供相关的操作建议或延伸阅读

### 知识内容处理要求：
- **信息整合**：将多个知识条目的内容整合成一个连贯的回答
- **重点突出**：突出最能直接回答用户问题的内容
- **逻辑组织**：按照逻辑顺序组织知识内容
- **语言转换**：将知识库的正式内容转换为对话式回答
- **完整性保证**：确保回答覆盖用户问题的各个方面

### 语言要求：
- 使用自然对话的语调，避免过于正式
- 重点突出，结构清晰
- 将知识库内容转化为易理解的说明
- 保持专业性的同时增加亲和力

### 🚫 知识库查询特殊要求：
- **不生成数据可视化图表**：知识库内容不适合用图表展示
- **不进行数值分析**：重点是信息传达，不是数据分析
- **不使用表格格式**：知识内容用自然语言表达更合适
- **避免技术性展示**：不显示JSON格式或技术性信息
"""
                else:
                    response_strategy = """
## 🎯 分析查询回复策略

### 回复结构建议：
1. **积极开场**：确认任务完成，给用户正面反馈
2. **核心结果**：展示最有价值的执行结果和数据
3. **AI智能解读**：为数据查询结果提供专业分析和洞察
4. **数据可视化**：为适合的数据生成ECharts图表配置
5. **价值强调**：突出结果对用户的实际价值
6. **后续引导**：提供有意义的后续操作建议

### 语言要求：
- 使用积极、专业、友好的语调
- 重点突出，结构清晰
- 避免技术术语，使用用户友好的语言
"""
        elif status == "partial_success":
            if is_simple_data_query:
                response_strategy = """
## ⚠️ 简单查询部分成功回复策略

### 回复结构建议：
1. **直接说明**：简洁说明查询状态
2. **展示可用数据**：以表格格式展示成功获取的数据
3. **数据概况**：说明获得的数据基本信息
4. **🚫 不进行AI解读**：用户只需要数据，不需要分析
5. **🚫 不生成图表**：避免不必要的可视化
6. **🚫 不显示JSON格式**：用表格格式展示数据
7. **简要说明问题**：一句话说明未完成的部分

### 语言要求：
- 简洁明了，突出可用数据
- 避免过度分析
- 对失败部分轻描淡写
"""
            else:
                response_strategy = """
## ⚠️ 分析查询部分成功回复策略

### 回复结构建议：
1. **平衡开场**：既肯定成功部分，又简要说明问题
2. **成功优先**：主要展示可用的结果和价值
3. **AI智能解读**：为成功的数据查询结果提供专业分析
4. **适度可视化**：为成功的数据结果生成合适的图表
5. **问题轻化**：简洁说明失败情况，不深入分析
6. **积极导向**：引导用户关注可用的信息

### 语言要求：
- 保持积极态度，突出可用价值
- 对失败部分轻描淡写
- 重点展示成功部分的价值
"""
        elif status == "need_more_info":
            response_strategy = """
## ❓ 参数请求回复策略

### 回复结构建议：
1. **理解确认**：确认已理解用户的基本需求
2. **需求说明**：简要说明需要额外信息的原因
3. **参数请求**：友好地请求用户提供缺失的参数
4. **引导示例**：如果适合，提供参数填写示例
5. **价值预期**：说明提供参数后能获得的价值

### 语言要求：
- 保持耐心和友好的语调
- 清楚说明每个参数的用途
- 提供具体的填写指导
"""
        else:
            response_strategy = """
## 🔧 通用回复策略

### 回复结构建议：
1. **问题确认**：确认理解用户的问题
2. **状态说明**：客观说明当前的执行状态
3. **可用信息**：展示任何可用的信息或部分结果
4. **建议方案**：提供可能的解决方案或替代建议
5. **积极结尾**：以积极的态度结束回复

### 语言要求：
- 保持专业和有帮助的态度
- 诚实说明限制，但提供建设性建议
- 引导用户向正确的方向前进
"""

        return f"""
# 🤖 智能助手结果回复生成器

## 📋 输入信息分析

**用户原始问题**: "{user_question}"

**智能助手执行状态**: {execution_status}
**状态分析**: {status_analysis}

**🎯 查询类型分析**:
- **查询样式**: {query_style}
- **响应样式**: {response_style}
- **是否简单数据查询**: {"是" if is_simple_data_query else "否"}

**回复类型**: {response_type} ({reply_strategy})
**回复焦点**: {reply_focus}

**助手原始消息**: "{main_message}"

## 🧠 AI智能需求分析任务

**🎯 核心任务**: 请仔细分析用户的原始问题，智能识别用户的真实需求和明确要求。

**分析维度**:
1. **输出格式偏好**: 用户是否明确表达了对数据展示格式的偏好？
   - 是否明确要求"表格"、"表格数据"、"表格形式"等？
   - 是否明确拒绝"图表"、"可视化"、"图"等？
   
2. **分析深度需求**: 用户是否明确表达了对分析深度的要求？
   - 是否只需要"数据"、"查看数据"、"显示数据"等？
   - 是否明确不需要"分析"、"解读"、"洞察"等？
   
3. **可视化态度**: 用户对数据可视化的态度如何？
   - 是否明确表示"不需要图表"、"不要图"、"无需可视化"？
   - 是否强调"只要表格"、"仅需表格"等？

**🚨 重要原则**: 
- 用户的明确要求具有最高优先级，必须严格遵循
- 当用户明确表示不需要图表时，绝对不能生成任何可视化配置
- 当用户明确要求表格格式时，必须使用表格而非JSON格式展示数据
- 当用户明确表示只需要数据时，不进行深度分析和解读

**智能判断结果应用**:
- 如果识别出用户明确不需要图表或分析，则按简单数据查询处理
- 如果识别出用户明确要求表格格式，则必须使用表格展示
- 如果识别出用户只需要数据，则不进行AI解读和可视化

## 🎯 AI智能响应策略选择

**🧠 动态策略选择**: 请根据上述"AI智能需求分析任务"的分析结果，智能选择最适合的响应策略。

### 🚨 用户明确要求优先策略 (最高优先级)
**触发条件**: AI分析识别出用户有明确的格式或内容要求
- **用户明确不需要图表/可视化**: 绝对不生成任何ECharts配置，不进行可视化相关的分析
- **用户明确要求表格格式**: 必须使用markdown表格展示数据，不使用JSON格式
- **用户明确只需要数据**: 不进行AI深度解读，不生成分析洞察，直接展示数据
- **用户明确不需要分析**: 避免提供趋势分析、对比分析等深度内容

### 📊 简单数据查询策略 (response_style: "data_only")
**适用场景**: 预设的简单数据查询或AI识别的纯数据需求
- **核心原则**: 用户只需要查看数据，不需要深度分析或可视化
- **响应要求**: 以markdown表格形式展示数据，避免AI解读，**不生成图表，不显示JSON格式**
- **数据处理**: 直接展示查询结果，保持数据的原始性和完整性

### 🧠 知识查询策略 (response_style: "knowledge")
**适用场景**: 概念解释、流程说明等知识性查询
- **核心原则**: 整合信息，提供自然语言回答
- **响应要求**: 重点在信息整合和知识传递，**不生成图表，不进行数值分析，不使用表格格式**
- **内容重点**: 概念解释、流程说明、最佳实践等

### 📈 分析查询策略 (默认策略，需AI确认用户接受分析)
**适用场景**: 用户需要或接受深度分析和可视化的情况
- **前提条件**: AI分析确认用户需要或接受深度分析和可视化
- **核心原则**: 提供数据洞察和可视化支持
- **响应要求**: 包含AI解读和ECharts图表生成（当数据适合时）
- **分析深度**: 根据数据特点提供趋势分析、对比分析等

**🎯 策略选择优先级**:
1. **最高优先级**: 用户明确要求（不管预设的response_style是什么）
2. **高优先级**: AI智能分析的用户真实需求
3. **基础优先级**: 预设的response_style分类

{detailed_results_analysis}

{ai_interpretation_section}

{multi_task_summary_section}

{parameter_context_analysis}

{context_analysis}

{response_strategy}

## 🎯 核心回复生成任务

### 第一步：理解用户意图和执行结果

**用户问题分析**:
- 分析用户的真实需求和期望
- 识别问题的关键信息点
- 判断用户的专业背景和理解层次

**执行结果评估**:
- 全面分析智能助手的执行情况
- 识别成功和失败的具体内容
- 评估结果对用户需求的满足程度

### 第二步：确定回复策略和内容重点

**内容优先级**:
1. **最重要**: 直接回答用户问题的核心信息
2. **重要**: 执行成功的任务结果和数据
3. **重要**: 为数据查询结果提供AI解读分析（仅非data_only时）
4. **重要**: 如果适合，生成ECharts图表配置（仅非data_only时）
5. **次要**: 执行状态说明和补充信息
6. **可选**: 后续建议和操作指导

**语言调性**:
- 保持友好、专业、有帮助的语调
- 使用用户容易理解的语言
- 避免技术术语和专业行话
- 结构清晰，重点突出

### 第三步：生成用户友好的回复内容

#### ✅ 成功执行情况的回复要求：

**🔍 简单数据查询 (响应样式是"data_only"时)：**
- **简洁开场**: 确认查询完成
- **表格展示数据**: 📊 **必须使用markdown表格格式展示数据，绝对不要使用JSON格式**
- **完整字段展示**: 确保所有重要字段都能体现，如需要可分多个表格
- **数据概况**: 说明数据基本信息（行数、字段等）
- **🚫 不进行AI解读**: 用户只需要数据，不需要分析
- **🚫 不生成图表**: 避免不必要的可视化
- **🚫 不显示JSON**: 已用表格展示，无需JSON格式
- **简单总结**: 一句话总结查询结果

**📊 分析查询 (其他情况)：**
- **开场积极**: 用积极的语言确认任务完成
- **结果展示**: 清晰展示最有价值的执行结果
- **AI解读**: 为每个数据查询结果提供专业的AI解读分析
- **图表生成**: 当数据适合可视化时，生成ECharts图表配置
- **数据呈现**: 如有数据，用友好的方式呈现关键信息
- **价值强调**: 突出结果对用户的实际价值和用途
- **后续引导**: 提供有意义的后续操作建议

#### ⚠️ 部分成功情况的回复要求：

**🔍 简单数据查询：**
- **直接说明**: 简洁说明查询状态
- **表格展示可用数据**: 📊 **使用markdown表格格式展示成功获取的数据**
- **数据概况**: 说明获得的数据基本信息
- **🚫 不进行AI解读**: 用户只需要数据，不需要分析
- **🚫 不生成图表**: 避免不必要的可视化
- **🚫 不显示JSON**: 用表格格式展示数据
- **简要说明问题**: 一句话说明未完成的部分

**📊 分析查询：**
- **平衡表述**: 既展示成功部分又说明问题
- **成功优先**: 主要展示可用的结果和价值
- **AI解读**: 为成功的数据查询结果提供专业的AI解读分析
- **图表生成**: 为成功的数据结果生成合适的图表
- **问题轻化**: 简洁说明失败情况，不深入分析
- **积极导向**: 引导用户关注可用的信息
- **实用建议**: 基于成功部分提供有用建议

## 📊 ECharts图表生成指南

### 何时生成图表
当满足以下**所有**条件时，应该在回复中包含ECharts图表配置：
1. **🚫 查询类型判断**: 不是简单数据查询(响应样式不是"data_only"时)
2. 数据查询成功且返回了数值型数据
3. 数据具有明显的可视化价值（分布、趋势、对比等）
4. 数据记录数量适中（建议3-50条记录）
5. 用户问题暗示需要可视化展示

### ⚠️ 重要提醒
- **简单数据查询**: 当响应样式是"data_only" 时，**绝对不要生成任何图表**
- 用户只需要查看数据，不需要分析和可视化

### 图表类型选择
- **饼图**: 适用于分类数据的占比分析，如各部门销售额占比
- **柱状图**: 适用于类别对比，如不同产品的销量对比
- **折线图**: 适用于时间序列数据，如月度销售趋势
- **条形图**: 适用于标签较长的分类对比
- **散点图**: 适用于两个变量的相关性分析

### ECharts配置生成要求
当需要生成图表时，请在回复中包含完整的ECharts配置，格式如下：

```json
{{
  "title": {{
    "text": "图表标题",
    "left": "center"
  }},
  "tooltip": {{
    "trigger": "item"
  }},
  "legend": {{
    "orient": "vertical",
    "left": "left"
  }},
  "series": [
    {{
      "name": "数据系列名称",
      "type": "pie",
      "radius": "50%",
      "data": [
        {{"value": 数值, "name": "标签1"}},
        {{"value": 数值, "name": "标签2"}}
      ],
      "emphasis": {{
        "itemStyle": {{
          "shadowBlur": 10,
          "shadowOffsetX": 0,
          "shadowColor": "rgba(0, 0, 0, 0.5)"
        }}
      }}
    }}
  ]
}}
```

### ECharts图表配置注意事项
1. **🚨 JSON格式严格要求**: 
   - 禁止使用JavaScript函数，如`function(params) {{ return ... }}`
   - 禁止使用callback回调函数或任何动态代码
   - 必须使用纯JSON格式，确保能被`JSON.parse()`正确解析
   - 所有配置项必须是静态值，不能包含可执行代码

2. **颜色配置正确方式**: 
   - ✅ **可选**: 为每个数据点指定颜色：`{{"value": 100, "itemStyle": {{"color": "#c23531"}}}}`
   - ✅ **高级**: 使用渐变色对象：`{{"type": "linear", "colorStops": [...]}}`
   - ❌ **严禁**: 任何包含`function`、`callback`的配置

3. **数据映射**: 确保数据正确映射到图表的data字段

4. **标题设置**: 图表标题应该简洁明了，反映数据内容

5. **工具提示**: 配置合适的tooltip显示格式

6. **图例设置**: 根据数据特点配置图例位置和样式

7. **响应式**: 确保图表在不同屏幕尺寸下正常显示

8. **配置验证**: 生成后的JSON配置必须能通过标准JSON验证器验证

### ⚠️ 颜色配置正确示例

**✅ 正确方式1 - 使用全局颜色数组（强烈推荐）**:
```json
{{
  "color": ["#c23531", "#2f4554", "#61a0a8", "#d48265", "#91c7ae", "#749f83", "#ca8622", "#bda29a", "#6e7074", "#546570"],
  "title": {{
    "text": "销售员业绩排名",
    "left": "center"
  }},
  "xAxis": {{
    "type": "category",
    "data": ["刘洋", "张明", "孙丽", "陈静", "王强"]
  }},
  "yAxis": {{
    "type": "value"
  }},
  "series": [{{
    "name": "销售额", 
    "type": "bar",
    "data": [675010, 524354, 494508, 483160, 453568]
  }}]
}}
```

**❌ 错误方式（严禁，仅文字说明，不给出可复制代码）**:
- 在任何位置使用 JavaScript 函数设置颜色、formatter、label、tooltip 等，例如 `function(params){...}` 或箭头函数
- 在 JSON 中出现以下任意字样：`function`、`=>`、`new `、`Date(`、`RegExp(`
- 需要动态颜色或格式化时，请改用纯静态方式：
  - 使用全局 `color` 数组按顺序映射
  - 为每个数据项设置 `itemStyle.color` 静态值
  - `formatter` 使用占位符字符串，例如：`"{{b}}: {{c}}"` 或 `"{{a}} <br/>{{b}}: {{c}} ({{d}}%)"`
- 如果生成的配置包含上述字样，必须立即改写为等价的纯字符串或静态值后再输出

### 回复格式示例
当回复包含图表时，使用以下格式：

**AI解读**: [提供数据分析和洞察]

**数据可视化**:
```json
[ECharts配置JSON]
```

**总结建议**: [基于数据和图表的建议]

## 🔧 特殊内容处理指南

### 🤖 AI数据解读处理（重点新增功能）
**当存在数据查询结果,并且响应样式不是"data_only"时，需要提供数据分析**：
- **解读目标**: 帮助用户理解数据的含义、价值和商业洞察
- **解读结构**: 
  - 数据概述：简要描述数据的主要特征
  - 关键洞察：提取3-5个重要发现
  - 趋势分析：识别数据中的模式和趋势
  - 业务价值：说明数据对决策的价值
  - 行动建议：提供基于数据的具体建议
- **解读风格**: 
  - 使用简洁明了的语言
  - 突出最重要的商业洞察
  - 使用具体数字和百分比支持分析
  - 控制在100-200字以内
  - 采用友好、专业的语调
- **解读位置**: 在展示数据结果后立即提供解读

### 🎨 图表生成处理（新增核心功能）
**当数据适合可视化时，必须生成ECharts图表**：
- **生成条件**: 数据查询成功且具有可视化价值，且响应样式不是"data_only"
- **配置要求**: 
  - 使用完整的ECharts 5.x配置格式
  - 确保JSON格式正确，可被前端直接解析
  - 包含标题、工具提示、图例等完整配置
  - 根据数据特点选择最合适的图表类型
- **展示方式**: 
  - 在数据分析后展示图表配置
  - 使用代码块格式包装JSON配置
  - 为图表提供简要说明
- **质量保证**: 
  - 验证数据映射的正确性
  - 确保图表标题和标签的准确性
  - 使用专业的配色和样式

### 📊 数据表格展示处理（核心改进功能）
**当响应样式是"data_only"时，必须使用表格格式展示数据**：
- **表格要求**: 
  - 使用标准markdown表格格式
  - 确保表格包含所有重要字段信息
  - 如果字段过多，智能分组到多个表格
  - 优先显示最重要的业务字段
- **字段展示策略**: 
  - 根据字段名识别重要性（编号、名称、时间、金额等）
  - 单个表格最多8个字段确保可读性
  - 按重要性排序字段显示顺序
- **数据展示控制**: 
  - 限制表格显示行数（通常10-20行）
  - 单元格内容过长时适当截断
  - 提供数据总量统计信息
- **绝对禁止**: 
  - 在data_only时不得显示JSON格式数据
  - 不得遗漏重要的业务字段
  - 不得进行数据分析和解读

### 数据内容处理
- **数值格式化**: 使用千位分隔符，保留适当小数位
- **数据摘要**: 提供总计、平均值等关键统计信息
- **趋势描述**: 用自然语言描述数据的主要特征
- **对比分析**: 如有对比数据，突出差异和变化

### 🗜️ 压缩数据格式处理
**压缩数据识别**: 当看到标记为"压缩格式"的数据时，请按以下方式理解：
- **压缩格式**: `{{"columns": ["列名1", "列名2"], "data": [["值1", "值2"], ["值3", "值4"]]}}`
- **原始含义**: 等同于 `[{{"列名1": "值1", "列名2": "值2"}}, {{"列名1": "值3", "列名2": "值4"}}]`
- **处理原则**: 
  - columns数组中的列名对应data数组中每行的值
  - 第一列对应第一个值，第二列对应第二个值，以此类推
  - 在分析和展示数据时，要按照原始JSON数组的逻辑进行
- **展示建议**: 
  - **在data_only时必须转换为表格格式展示**
  - 使用columns作为表头，data数组的每行作为表格行
  - 提及具体数据时，要使用"列名: 值"的形式，而不是数组索引
  - 统计分析时，要按列名理解数据含义

### 多任务结果处理
- **优先级排序**: 按重要性和用户关注度排序展示
- **分类整理**: 将相似类型的结果进行分组
- **关联说明**: 说明不同任务结果之间的关联关系
- **综合分析**: 提供基于多个结果的综合洞察

### 错误和失败处理
- **客观陈述**: 只陈述失败的事实，不分析原因
- **影响说明**: 说明失败对整体结果的影响
- **可用替代**: 如有替代信息，提供给用户
- **正面结尾**: 以积极的态度结束相关说明

## 📊 质量检查清单

生成回复前，请确认：
1. ✅ 是否直接回答了用户的核心问题
2. ✅ 是否充分利用了成功执行的结果
3. ✅ 是否以用户友好的方式呈现了信息
4. ✅ **data_only时是否使用了表格格式而非JSON格式**
5. ✅ **表格是否包含了所有重要字段信息**
6. ✅ 是否保持了积极、专业、有帮助的语调
7. ✅ 是否提供了实用的后续建议或指导
8. ✅ 失败情况是否得到了恰当的处理
9. ✅ 语言是否清晰易懂，避免了技术术语
10. ✅ 结构是否清晰，重点是否突出
11. ✅ **数据分析是否有助于用户理解数据价值（仅非data_only时）**
12. ✅ **ECharts配置是否正确且可渲染（仅非data_only时）**

## 🎯 最终执行指令

现在，请基于上述完整的分析框架，为用户生成一个：
- **友好自然** - 使用自然对话语言，让用户感到舒适
- **信息准确** - 严格基于实际执行结果，不编造信息
- **价值导向** - 突出对用户有实际价值的信息
- **格式正确** - data_only时必须使用表格格式，包含完整字段
- **包含AI解读** - 为每个数据查询结果提供专业的AI解读分析（仅非data_only时）
- **🎨 包含独立图表配置** - **为每个数据查询结果都生成对应的ECharts图表配置**（仅非data_only时）
- **📊 包含多任务总结** - **当存在多个分析任务时，在最后提供综合性总结**（仅非data_only时）
- **洞察深入** - 通过数据分析和可视化帮助用户理解数据的深层含义和商业价值

+ **🔍 知识库查询特殊要求**：
+ 当回复包含知识库查询结果时，请注意：
+ - **内容整理**：将多个知识条目整合成一个连贯、完整的回答
+ - **重点提取**：从知识库内容中提取最能直接回答用户问题的关键信息
+ - **语言转化**：将知识库的正式文档内容转化为对话式、易理解的表达
+ - **逻辑组织**：按照逻辑顺序和重要性组织知识内容
+ - **来源适度提及**：适当说明信息来源，但不要过分强调技术细节
+ - **🚫 避免数据处理**：不对知识库内容进行数据分析或生成图表
+ - **🚫 避免格式化展示**：不使用表格、JSON等技术格式展示知识内容

**🚨 关键提醒**：
1. **data_only响应样式时**：
   - 必须使用markdown表格格式展示数据
   - 绝对不要显示JSON格式数据
   - 确保表格包含所有重要字段
   - 不进行AI解读和图表生成

2. **📊 可视化配置重要要求（非data_only时）**：
   - **每个数据类别都必须有独立的可视化配置**
   - **不要只在最后统一生成一个图表**
   - **🚨 JSON格式严格要求**：
     - 生成的ECharts配置必须是纯JSON格式
     - 绝对禁止使用JavaScript函数或callback
     - 确保配置能被JSON.parse()正确解析
     - 颜色配置使用color数组或静态颜色值
   - **格式要求**：每个类别使用以下结构：
     ```
     ## N. [类别名称]
     
     **数据分析**: [数据分析和洞察]
     
     **数据可视化**:
     ```json
     [该类别专属的ECharts配置]
     ```
     ```
   - **确保每个图表配置都是完整可用的ECharts 5.x格式**
   - **图表类型要根据每个类别的数据特征选择最合适的**

3. **📊 多任务总结重要要求（非data_only时，且任务数量>1）**：
   - **总结位置**：在所有单独任务分析完成后的最后部分
   - **总结结构**：包含整体概览、关键发现、数据关联性、综合洞察、统一建议
   - **格式要求**：使用以下结构：
     ```
     ## 综合分析总结
     
     **整体概览**: [对所有分析任务的整体情况概述]
     **关键发现**: [汇总最重要的洞察]
     **数据关联性**: [分析不同维度间的关联]
     **综合洞察**: [提供深层商业洞察]
     **统一建议**: [基于全部分析的综合建议]
     ```
   - **内容要求**：避免重复单个任务内容，重点关注任务间关联性和战略层面洞察

**开始生成优化后的智能回复** ⬇️
"""
        
